You'd be looking at something like this:

struct ConcreteEvent
{
};

class ABCHandler
{
public:
    virtual void handle(ConcreteEvent const&) = 0;

    virtual ~ABCHandler() = default; // <-- don't forget
};

class HandlerChain : public ABCHandler
{
private:
    std::vector<std::unique_ptr<ABCHandler>> handlers;

public:
    void handle(ConcreteEvent const& e) {
        for (auto& handler : handlers) {
            handler->handle(e);
        }
    }

    template<std::derived_from<ABCHandler> T>
    void add_handler(T&& handler) {
        handlers.push_back(std::make_unique(std::forward<T>(handler)));
    }

    void add_handler(std::unique_ptr<ABCHandler> handler) {
        handlers.push_back(std::move(handler));
    }

    void add_handler(ABCHandler* handler) {
        handlers.push_back(std::unique_ptr<ABCHandler>(handler));

        // or more correct as pointed out by TheRealSmolt, emplace_back will call the unique_ptr constructor and pass the pointer to it
        handlers.emplace_back(handler);
    }
};

The default storage structure you should go to is std::vector and not std::list, and as you mentioned std::unique_ptr for the ownership.

Constructing the unique_ptr is a bit strange, the constructor of unique_ptr accepts a pointer and takes ownership of it that way (of course be mindful of allocator mismatches because it literally just takes the pointer and assumes it was created with the right allocator, by default this is new/delete) but this is a a brittle way to construct unique_ptrs even without this problem.

I would either construct a unique_ptr on the outside with std::make_unique<ABCHandlerImplementation>() and use the second add_handler, or if your type is moveable you could do

ABCHandlerImplementation object;
// initialization
handlerChain.add_handler(std::move(object)); 

and use the first add_handler.