c++ covariant constructions with respect to template parameters

I have a base class and its derived class with pointers to forward declared classes:

class BaseParam;

template <class S = BaseParam> class Base;

class BaseParam {
private:
    std::unique_ptr<Base<>> ptr;
public:
    virtual const Base<>& get_ptr() const {return *ptr;}
};

And similarly for its derived class

class DerivedParam;

template <class S = DerivedParam> class Derived;

class DerivedParam : public BaseParam {
private:
    std::unique_ptr<Derived<>> ptr;
public:
     const Derived<>& get_ptr() const override {return *ptr;}  // <---- Here we'll have trouble
};

The above mentioned class templates are also intertwined with the Param versions, here's the prototype:

template <class S>
class Base {
private:
    std::unique_ptr<S> ptr;
    // ...
public:
    // ...
    const S& get_ptr() const { return *ptr; }
};

template <class S>
class Derived : public Base<S> {
};

So that Derived = Derived<DerivedParam> inherits from Base<DerivedParam> But in order to make the return marked with <-- above covariant, we would need Derived to inherit from Base = Base<BaseParam>. How does one do this in a clean fashion? I cannot add an extra inheritance say like

template <class S>
class Derived: public Base<S>, public virtual Base<>

Cause Base and Base<DerivedParam> will hold two different pointers to BaseParam and to DerivedParam. Since a pointer to DerivedParam decays to one to BaseParam there should be a solution where the base class holds only one pointer.

So what I am asking is if there is some functorial way of defining class inheritance for class templates.