diff --git a/include/sdbusplus/asio/connection.hpp b/include/sdbusplus/asio/connection.hpp
index a164ac1..4874f62 100644
--- a/include/sdbusplus/asio/connection.hpp
+++ b/include/sdbusplus/asio/connection.hpp
@@ -74,29 +74,19 @@
      *         upon return and return
      *
      *  @param[in] m - A message ready to send
-     *  @param[in] handler - handler to execute upon completion; this may be an
-     *                       asio::yield_context to execute asynchronously as a
-     *                       coroutine
+     *  @param[in] token- The completion token to execute upon completion;
      *
-     *  @return If a yield context is passed as the handler, the return type is
-     *          a message. If a function object is passed in as the handler,
-     *          the return type is the result of the handler registration,
-     *          while the resulting message will get passed into the handler.
      */
-    template <typename MessageHandler>
-    inline BOOST_ASIO_INITFN_RESULT_TYPE(MessageHandler,
-                                         void(boost::system::error_code,
-                                              message_t&))
-        async_send(message_t& m, MessageHandler&& handler, uint64_t timeout = 0)
+    template <typename CompletionToken>
+    inline auto async_send(message_t& m, CompletionToken&& token,
+                           uint64_t timeout = 0)
     {
-        boost::asio::async_completion<
-            MessageHandler, void(boost::system::error_code, message_t)>
-            init(handler);
-        detail::async_send_handler<typename boost::asio::async_result<
-            MessageHandler, void(boost::system::error_code,
-                                 message_t)>::completion_handler_type>(
-            std::move(init.completion_handler))(get(), m, timeout);
-        return init.result.get();
+        constexpr bool is_yield =
+            std::is_same_v<CompletionToken, boost::asio::yield_context>;
+        using return_t = std::conditional_t<is_yield, message_t, message_t&>;
+        using callback_t = void(boost::system::error_code, return_t);
+        return boost::asio::async_initiate<CompletionToken, callback_t>(
+            detail::async_send_handler(get(), m, timeout), token);
     }
 
     /** @brief Perform an asynchronous method call, with input parameter packing
diff --git a/include/sdbusplus/asio/detail/async_send_handler.hpp b/include/sdbusplus/asio/detail/async_send_handler.hpp
index 144a56a..0f40ce9 100644
--- a/include/sdbusplus/asio/detail/async_send_handler.hpp
+++ b/include/sdbusplus/asio/detail/async_send_handler.hpp
@@ -27,35 +27,31 @@
 {
 namespace detail
 {
-template <typename Handler>
-struct async_send_handler
+
+/* Class meant for converting a static callback, and void* userdata from sd-bus
+ * back into a structured class to be returned to the user.
+ */
+template <typename CompletionToken>
+struct unpack_userdata
 {
-    Handler handler_;
-    async_send_handler(Handler&& handler) : handler_(std::move(handler)) {}
-    async_send_handler(Handler& handler) : handler_(handler) {}
-    void operator()(sd_bus* conn, message_t& mesg, uint64_t timeout)
+    CompletionToken handler_;
+
+    static int do_unpack(sd_bus_message* mesg, void* userdata,
+                         sd_bus_error* /*error*/)
     {
-        async_send_handler* context = new async_send_handler(std::move(*this));
-        int ec = sd_bus_call_async(conn, NULL, mesg.get(), &callback, context,
-                                   timeout);
-        if (ec < 0)
-        {
-            // add a deleter to context because handler may throw
-            std::unique_ptr<async_send_handler> safe_context(context);
-            auto err =
-                make_error_code(static_cast<boost::system::errc::errc_t>(ec));
-            context->handler_(err, mesg);
-        }
-    }
-    static int callback(sd_bus_message* mesg, void* userdata,
-                        sd_bus_error* /*error*/)
-    {
-        if (userdata == nullptr || mesg == nullptr)
+        if (userdata == nullptr)
         {
             return -1;
         }
-        std::unique_ptr<async_send_handler> context(
-            static_cast<async_send_handler*>(userdata));
+
+        // Take RAII ownership of the pointer again
+        using self_t = unpack_userdata<CompletionToken>;
+        std::unique_ptr<self_t> context(static_cast<self_t*>(userdata));
+
+        if (mesg == nullptr)
+        {
+            return -1;
+        }
         message_t message(mesg);
         auto ec = make_error_code(
             static_cast<boost::system::errc::errc_t>(message.get_errno()));
@@ -63,6 +59,32 @@
         return 1;
     }
 };
+
+struct async_send_handler
+{
+    sd_bus* bus;
+    message_t& mesg;
+    uint64_t timeout;
+
+    template <typename CompletionToken>
+    void operator()(CompletionToken&& token)
+    {
+        using unpack_t = unpack_userdata<CompletionToken>;
+        auto context = std::make_unique<unpack_t>(std::move(token));
+        int ec = sd_bus_call_async(bus, NULL, mesg.get(), &unpack_t::do_unpack,
+                                   context.get(), timeout);
+        if (ec < 0)
+        {
+            auto err =
+                make_error_code(static_cast<boost::system::errc::errc_t>(ec));
+            context->handler_(err, mesg);
+            return;
+        }
+        // If the call succeeded, sd-bus owns the pointer now, so release it
+        // without freeing.
+        context.release();
+    }
+};
 } // namespace detail
 } // namespace asio
 } // namespace sdbusplus