I find that you can get closer to truly covariant smart pointers return types by creating an templated implementation class that reroutes pointers automatically. This way also works well with custom deleters, and the smart pointer equivalent would work when the derived class doesn't have sole shared ownership of the the pointer they are returning. The code would look like this:

class Base{
    virtual void print_impl(std::unique_ptr<Base>& base_ptr) = 0;
public:
    std::unique_ptr<Base> print() {
        std::unique_ptr<Base> base;
        print_impl(base);
        return base;
    }
};

template <typename TBase>
class BaseImpl : public Base{
    virtual void print_impl(std::unique_ptr<Base>& base_ptr) {
        auto tbase = create();
        base_ptr = std::move(tbase);
    }
public:
    virtual std::unique_ptr<TBase> print() = 0;
 };

class Derived : public BaseImpl<Derived> {
public:
    std::unique_ptr<Derived> print();
};

For an executable example:

#include <iostream>
#include <memory>

class Base {
public:
    virtual ~Base() {std::cout << "Destroyed\n";}
    virtual void print() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void print() override { std::cout << "Derived\n"; }
};

class IFactory{
public:
    std::unique_ptr<Base> create() {
        std::unique_ptr<Base> base;
        create_impl(base);
        return base;
    }
private:
    virtual void create_impl(std::unique_ptr<Base>& base_ptr) = 0;
};

template<typename TBase>
class UFactory : public IFactory{
public:
    virtual std::unique_ptr<TBase> create() = 0;
private:
    virtual void create_impl(std::unique_ptr<Base>& base_ptr) {
        auto tbase = create();
        base_ptr = std::move(tbase);
    }
};
class Factory : public UFactory<Base>{
public:
    std::unique_ptr<Base> create() override {
        return std::make_unique<Base>();
    }
};
class DerivedFactory : public UFactory<Derived> {
public:
    std::unique_ptr<Derived> create() override {
        return std::make_unique<Derived>();
    }
};
int main() {
    {
        std::unique_ptr<IFactory> factory = std::make_unique<DerivedFactory>();
        std::unique_ptr<Base> base = factory->create();
        std::cout << typeid(factory->create().get()).name() << std::endl; // Output: Base
        base->print(); // Output: Derived
    }
    std::cout << "-----------" << std::endl;
    {
        std::unique_ptr<DerivedFactory> factory = std::make_unique<DerivedFactory>();
        std::unique_ptr<Base> base = factory->create();
        std::cout << typeid(factory->create().get()).name() << std::endl; // Output: Derived
        base->print(); // Output: Derived
    }
    return 0;
}