The answer is yes, and it will look like this:
    enum class A { voilet, blue, roses, red};
    constexpr A enum_obj= A::blue;
    Enum_wrapper B{enum_obj};

    enum class enum_2 { voilet, blue, roses, red};

    enum_2 enum_obj_2=  enum_2 ::blue ;

    Enum_wrapper <enum_2,  Enum_wrapper <A>>   second_wrapper{ enum_obj_2  };

    When the code is finished, then the object "second_wrapper" could be assigned enum_obj as well, and when accessed in a context requiring 

    an enum, then the object will return enum_obj as an Enum_wrapper <A>. That is the main goal of the whole thing. Any access requiring runtime tracking would still rely on std::variant and in fact I would try to write code that sees if any non-constival  operation   call happened in which case, the fall back is to use an variant stored in the object. The compiler can ofcourse optimize such a variant away if it is unused (in case the usage of the enum was all with other constexpr enums). To make sure that I can track an non constval call, I can instantiate a dummy object(such that their destructor is also instantiated (by a call)) in the call of any non consteval call using dummy template arguments, and when a consteval operation will only be chosen if the instantiation of that object does not exist (using a dummy template argument with a default value that checks if the specialization has a destructor that exists) before every check to see if a non consteval operation. My code already demonstrates some of how it is done.