diff --git a/silkworm/infra/concurrency/awaitable_wait_for_all.hpp b/silkworm/infra/concurrency/awaitable_wait_for_all.hpp
index 9933e159f1..183e942338 100644
--- a/silkworm/infra/concurrency/awaitable_wait_for_all.hpp
+++ b/silkworm/infra/concurrency/awaitable_wait_for_all.hpp
@@ -27,13 +27,13 @@
 
 #include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/awaitable.hpp>
-#include <boost/asio/co_spawn.hpp>
 #include <boost/asio/deferred.hpp>
 #include <boost/asio/experimental/awaitable_operators.hpp>
 #include <boost/asio/experimental/parallel_group.hpp>
 #include <boost/asio/this_coro.hpp>
 #include <boost/asio/use_awaitable.hpp>
 
+#include "co_spawn_sw.hpp"
 #include "parallel_group_utils.hpp"
 
 namespace silkworm::concurrency::awaitable_wait_for_all {
@@ -71,8 +71,8 @@ awaitable<void, Executor> operator&&(
 
     auto [order, ex0, ex1] =
         co_await make_parallel_group(
-            co_spawn(ex, std::move(t), deferred),
-            co_spawn(ex, std::move(u), deferred))
+            co_spawn_sw(ex, std::move(t), deferred),
+            co_spawn_sw(ex, std::move(u), deferred))
             .async_wait(
                 wait_for_one_error(),
                 use_awaitable_t<Executor>{});
@@ -93,8 +93,8 @@ awaitable<U, Executor> operator&&(
 
     auto [order, ex0, ex1, r1] =
         co_await make_parallel_group(
-            co_spawn(ex, std::move(t), deferred),
-            co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred))
+            co_spawn_sw(ex, std::move(t), deferred),
+            co_spawn_sw(ex, detail::awaitable_wrap(std::move(u)), deferred))
             .async_wait(
                 wait_for_one_error(),
                 use_awaitable_t<Executor>{});
@@ -115,8 +115,8 @@ awaitable<T, Executor> operator&&(
 
     auto [order, ex0, r0, ex1] =
         co_await make_parallel_group(
-            co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-            co_spawn(ex, std::move(u), deferred))
+            co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+            co_spawn_sw(ex, std::move(u), deferred))
             .async_wait(
                 wait_for_one_error(),
                 use_awaitable_t<Executor>{});
@@ -137,8 +137,8 @@ awaitable<std::tuple<T, U>, Executor> operator&&(
 
     auto [order, ex0, r0, ex1, r1] =
         co_await make_parallel_group(
-            co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-            co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred))
+            co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+            co_spawn_sw(ex, detail::awaitable_wrap(std::move(u)), deferred))
             .async_wait(
                 wait_for_one_error(),
                 use_awaitable_t<Executor>{});
@@ -161,8 +161,8 @@ awaitable<std::tuple<T..., std::monostate>, Executor> operator&&(
 
     auto [order, ex0, r0, ex1, r1] =
         co_await make_parallel_group(
-            co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-            co_spawn(ex, std::move(u), deferred))
+            co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+            co_spawn_sw(ex, std::move(u), deferred))
             .async_wait(
                 wait_for_one_error(),
                 use_awaitable_t<Executor>{});
@@ -183,8 +183,8 @@ awaitable<std::tuple<T..., U>, Executor> operator&&(
 
     auto [order, ex0, r0, ex1, r1] =
         co_await make_parallel_group(
-            co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-            co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred))
+            co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+            co_spawn_sw(ex, detail::awaitable_wrap(std::move(u)), deferred))
             .async_wait(
                 wait_for_one_error(),
                 use_awaitable_t<Executor>{});
diff --git a/silkworm/infra/concurrency/awaitable_wait_for_one.hpp b/silkworm/infra/concurrency/awaitable_wait_for_one.hpp
index 2542d4da2d..7c5e1e00d5 100644
--- a/silkworm/infra/concurrency/awaitable_wait_for_one.hpp
+++ b/silkworm/infra/concurrency/awaitable_wait_for_one.hpp
@@ -28,13 +28,14 @@
 
 #include <boost/asio/any_io_executor.hpp>
 #include <boost/asio/awaitable.hpp>
-#include <boost/asio/co_spawn.hpp>
 #include <boost/asio/deferred.hpp>
 #include <boost/asio/experimental/awaitable_operators.hpp>
 #include <boost/asio/experimental/parallel_group.hpp>
 #include <boost/asio/this_coro.hpp>
 #include <boost/asio/use_awaitable.hpp>
 
+#include "co_spawn_sw.hpp"
+
 namespace silkworm::concurrency::awaitable_wait_for_one {
 
 using boost::asio::experimental::wait_for_one;
@@ -69,7 +70,8 @@ awaitable<std::variant<std::monostate, std::monostate>, Executor> operator||(awa
     auto ex = co_await this_coro::executor;
 
     auto [order, ex0, ex1] =
-        co_await make_parallel_group(co_spawn(ex, std::move(t), deferred), co_spawn(ex, std::move(u), deferred))
+        co_await make_parallel_group(co_spawn_sw(ex, std::move(t), deferred),
+                                     co_spawn_sw(ex, std::move(u), deferred))
             .async_wait(wait_for_one(), use_awaitable_t<Executor>{});
 
     if (order[0] == 0) {
@@ -91,8 +93,8 @@ awaitable<std::variant<std::monostate, U>, Executor> operator||(awaitable<void,
     auto ex = co_await this_coro::executor;
 
     auto [order, ex0, ex1, r1] =
-        co_await make_parallel_group(co_spawn(ex, std::move(t), deferred),
-                                     co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred))
+        co_await make_parallel_group(co_spawn_sw(ex, std::move(t), deferred),
+                                     co_spawn_sw(ex, detail::awaitable_wrap(std::move(u)), deferred))
             .async_wait(wait_for_one(), use_awaitable_t<Executor>{});
 
     if (order[0] == 0) {
@@ -116,8 +118,8 @@ awaitable<std::variant<T, std::monostate>, Executor> operator||(awaitable<T, Exe
     auto ex = co_await this_coro::executor;
 
     auto [order, ex0, r0, ex1] =
-        co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-                                     co_spawn(ex, std::move(u), deferred))
+        co_await make_parallel_group(co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+                                     co_spawn_sw(ex, std::move(u), deferred))
             .async_wait(wait_for_one(), use_awaitable_t<Executor>{});
 
     if (order[0] == 0) {
@@ -141,8 +143,8 @@ awaitable<std::variant<T, U>, Executor> operator||(awaitable<T, Executor> t, awa
     auto ex = co_await this_coro::executor;
 
     auto [order, ex0, r0, ex1, r1] =
-        co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-                                     co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred))
+        co_await make_parallel_group(co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+                                     co_spawn_sw(ex, detail::awaitable_wrap(std::move(u)), deferred))
             .async_wait(wait_for_one(), use_awaitable_t<Executor>{});
 
     if (order[0] == 0) {
@@ -165,8 +167,8 @@ awaitable<std::variant<T..., std::monostate>, Executor> operator||(awaitable<std
     auto ex = co_await this_coro::executor;
 
     auto [order, ex0, r0, ex1] =
-        co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-                                     co_spawn(ex, std::move(u), deferred))
+        co_await make_parallel_group(co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+                                     co_spawn_sw(ex, std::move(u), deferred))
             .async_wait(wait_for_one(), use_awaitable_t<Executor>{});
 
     using widen = detail::widen_variant<T..., std::monostate>;
@@ -190,8 +192,8 @@ awaitable<std::variant<T..., U>, Executor> operator||(awaitable<std::variant<T..
     auto ex = co_await this_coro::executor;
 
     auto [order, ex0, r0, ex1, r1] =
-        co_await make_parallel_group(co_spawn(ex, detail::awaitable_wrap(std::move(t)), deferred),
-                                     co_spawn(ex, detail::awaitable_wrap(std::move(u)), deferred))
+        co_await make_parallel_group(co_spawn_sw(ex, detail::awaitable_wrap(std::move(t)), deferred),
+                                     co_spawn_sw(ex, detail::awaitable_wrap(std::move(u)), deferred))
             .async_wait(wait_for_one(), use_awaitable_t<Executor>{});
 
     using widen = detail::widen_variant<T..., U>;
diff --git a/silkworm/silkrpc/ethdb/kv/state_changes_stream.cpp b/silkworm/silkrpc/ethdb/kv/state_changes_stream.cpp
index c5468c1fd4..a3fe0e152e 100644
--- a/silkworm/silkrpc/ethdb/kv/state_changes_stream.cpp
+++ b/silkworm/silkrpc/ethdb/kv/state_changes_stream.cpp
@@ -23,6 +23,7 @@
 #include <boost/system/error_code.hpp>
 
 #include <silkworm/infra/common/log.hpp>
+#include <silkworm/infra/concurrency/co_spawn_sw.hpp>
 #include <silkworm/infra/concurrency/shared_service.hpp>
 #include <silkworm/silkrpc/grpc/util.hpp>
 
@@ -45,7 +46,7 @@ StateChangesStream::StateChangesStream(ClientContext& context, remote::KV::StubI
       retry_timer_{scheduler_} {}
 
 std::future<void> StateChangesStream::open() {
-    return boost::asio::co_spawn(scheduler_, run(), boost::asio::use_future);
+    return concurrency::co_spawn_sw(scheduler_, run(), boost::asio::use_future);
 }
 
 void StateChangesStream::close() {