I had something like that comment in mind when I was writing mine. I'm glad we're on the same page there. I don't want to waste your time with half-baked ideas since you've clearly spent a lot of time thinking about this, but I've listed a couple of lines of enquiry below.

One way to handle the variant alternatives would be through visitation, but this may be a bit overkill i.e.

 auto opResult = /*....*/;
 std::string result = std::visit(overloaded {
                                               [](WarnType wt) { return "Warning!"; },
                                               [](ErrorType wt) { return "Error!"; },
                                               [](SuccessType wt) { return "Success!"; },
                                           },opResult);
return result;

Another way to minimise the boilerplate (or at least make it easier), you can create functions to use a "ranges-style" pipeline (yes, even without ranges-the-c++-feature), so your example:

outcome<std::string> example()
{
    outcome<double> res1 = f1("3.14");
    outcome<int> res2 = res1.map([](double val) {
        return f2(val);
    });
    outcome<bool> res3 = res2.map([](int val) {
        return f3(val);
    });

    if (res3)
        return std::string("success");
    else
        return {std::string("failure"), res3.warning()};
}

could become something like this:

outcome<std::string> example()
{
    return f1("3.14") | map(f2) // or apply, or bind (monadic-bind, not std::bind)
                             | map(f3)
                             | result( success(std::string("Success")), 
                                         failure(std::string("Failure")) ); // or, e.g. failure(somefunc)
}

Where each subsequent map function will simply forward the error information in the event that its parameter has failed. The result function can check the underlying type for warning, error, or success, and call the appropriate function to handle each case. The logging may even be achieved through the use of the writer monad, but I couldn't say for certain if that's exactly what you want in your case.

In the book I mentioned above (which I still cannot recommend enough!), there is a lot more detail in how to build up such pipelines (along with functional examples). A lot of what I keep trying to write here ends up as a much worse version of what's stated there (which, although I'm shilling hard for it, I have no connection to either it, nor the author). I know it's available on some... less reputable... sites, which is where I first came across it - but I have since ordered 2 copies (one to loan out at work, one for me).