diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
index f24509dd97..105f4e4487 100644
--- a/src/test/net_tests.cpp
+++ b/src/test/net_tests.cpp
@@ -11,12 +11,14 @@
 #include <netaddress.h>
 #include <netbase.h>
 #include <netmessagemaker.h>
 #include <serialize.h>
 #include <span.h>
 #include <streams.h>
+#include <test/util/logging.h>
+#include <test/util/net.h>
 #include <test/util/setup_common.h>
 #include <test/util/validation.h>
 #include <timedata.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
@@ -902,7 +904,213 @@ BOOST_AUTO_TEST_CASE(initial_advertise_from_version_message)
     // PeerManager::ProcessMessage() calls AddTimeData() which changes the internal state
     // in timedata.cpp and later confuses the test "timedata_tests/addtimedata". Thus reset
     // that state as it was before our test was run.
     TestOnlyResetTimeData();
 }
 
+BOOST_AUTO_TEST_CASE(initial_messages_sent)
+{
+    LOCK(NetEventsInterface::g_msgproc_mutex);
+
+    m_node.args->ForceSetArg("-capturemessages", "1");
+
+    auto& connman = static_cast<ConnmanTestMsg&>(*m_node.connman);
+    auto& peerman = *m_node.peerman;
+
+    CNode outbound_peer{
+        /*id=*/NodeId{0},
+        /*sock=*/nullptr,
+        /*addrIn=*/CAddress{CService{CNetAddr{in_addr{.s_addr = htonl(0x01020304)}}, 8333}, NODE_NONE},
+        /*nKeyedNetGroupIn=*/0,
+        /*nLocalHostNonceIn=*/0,
+        /*addrBindIn=*/CAddress{},
+        /*addrNameIn=*/"",
+        /*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY,
+        /*inbound_onion=*/false};
+
+    std::unordered_map<std::string, size_t> count_sent_messages;
+
+    const auto CaptureMessageOrig = CaptureMessage;
+    CaptureMessage = [&count_sent_messages](const CAddress& addr,
+                                            const std::string& msg_type,
+                                            Span<const unsigned char> data,
+                                            bool is_incoming) -> void {
+        if (!is_incoming) {
+            count_sent_messages[msg_type]++;
+        }
+    };
+
+    connman.Handshake(
+        /*node=*/outbound_peer,
+        /*successfully_connected=*/true,
+        /*remote_services=*/ServiceFlags{NODE_NETWORK | NODE_WITNESS},
+        /*local_services=*/ServiceFlags{NODE_NETWORK | NODE_WITNESS},
+        /*version=*/PROTOCOL_VERSION,
+        /*relay_txs=*/true);
+
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::VERSION], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::WTXIDRELAY], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::SENDADDRV2], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::VERACK], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::GETADDR], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::SENDCMPCT], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::PING], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::GETHEADERS], 1);
+    BOOST_CHECK_EQUAL(count_sent_messages[NetMsgType::FEEFILTER], 1);
+
+    peerman.FinalizeNode(outbound_peer);
+
+    CaptureMessage = CaptureMessageOrig;
+    m_node.args->ForceSetArg("-capturemessages", "0");
+    // PeerManager::ProcessMessage() calls AddTimeData() which changes the internal state
+    // in timedata.cpp and later confuses the test "timedata_tests/addtimedata". Thus reset
+    // that state as it was before our test was run.
+    TestOnlyResetTimeData();
+}
+
+BOOST_AUTO_TEST_CASE(pingpong)
+{
+    // See PING_INTERVAL in net_processing.cpp
+    static constexpr auto PING_INTERVAL{2min};
+
+    m_node.args->ForceSetArg("-capturemessages", "1");
+
+    auto& connman = static_cast<ConnmanTestMsg&>(*m_node.connman);
+    auto& peerman = *m_node.peerman;
+
+    CNode outbound_peer{
+        /*id=*/NodeId{0},
+        /*sock=*/nullptr,
+        /*addrIn=*/CAddress{CService{CNetAddr{in_addr{.s_addr = htonl(0x01020304)}}, 8333}, NODE_NONE},
+        /*nKeyedNetGroupIn=*/0,
+        /*nLocalHostNonceIn=*/0,
+        /*addrBindIn=*/CAddress{},
+        /*addrNameIn=*/"",
+        /*conn_type_in=*/ConnectionType::OUTBOUND_FULL_RELAY,
+        /*inbound_onion=*/false};
+
+    auto CheckPingTimes = [&peerman, &outbound_peer](std::chrono::microseconds min_ping_time,
+                                                     std::chrono::microseconds last_ping_time,
+                                                     std::chrono::microseconds ping_wait) {
+        // Check min and last ping times
+        BOOST_CHECK_EQUAL(outbound_peer.m_min_ping_time.load().count(), min_ping_time.count());
+        BOOST_CHECK_EQUAL(outbound_peer.m_last_ping_time.load().count(), last_ping_time.count());
+
+        // Check if and how long current ping has been pending
+        CNodeStateStats stats;
+        BOOST_REQUIRE(peerman.GetNodeStateStats(outbound_peer.GetId(), stats));
+        BOOST_CHECK_EQUAL(stats.m_ping_wait.count(), ping_wait.count());
+    };
+
+    uint64_t ping_nonce_sent;
+
+    const auto CaptureMessageOrig = CaptureMessage;
+    CaptureMessage = [&ping_nonce_sent](const CAddress& addr,
+                                        const std::string& msg_type,
+                                        Span<const unsigned char> data,
+                                        bool is_incoming) {
+        if (!is_incoming && msg_type == NetMsgType::PING) {
+            CDataStream stream{data, SER_NETWORK, PROTOCOL_VERSION};
+            stream >> ping_nonce_sent;
+        }
+    };
+
+    const auto SendPing = [&peerman, &outbound_peer, &ping_nonce_sent]() EXCLUSIVE_LOCKS_REQUIRED(NetEventsInterface::g_msgproc_mutex) {
+        SetMockTime(GetMockTime() + PING_INTERVAL + 1s);
+        ping_nonce_sent = 0;
+        peerman.SendMessages(&outbound_peer);
+        BOOST_REQUIRE(ping_nonce_sent != 0);
+    };
+
+    const auto ReceiveAndProcessMessage = [&connman, &outbound_peer](CSerializedNetMsg& msg) EXCLUSIVE_LOCKS_REQUIRED(NetEventsInterface::g_msgproc_mutex) {
+        connman.ReceiveMsgFrom(outbound_peer, msg);
+        // The send buffer CConnman::nSendBufferMaxSize happens to be 0 during tests which
+        // trips fPauseSend to be set to true which cancels processing of incoming messages.
+        outbound_peer.fPauseSend = false;
+        connman.ProcessMessagesOnce(outbound_peer);
+    };
+
+    // Use mock time to control pings from node
+    SetMockTime(GetTime());
+
+    ping_nonce_sent = 0;
+
+    LOCK(NetEventsInterface::g_msgproc_mutex);
+
+    connman.Handshake(
+        /*node=*/outbound_peer,
+        /*successfully_connected=*/true,
+        /*remote_services=*/ServiceFlags{NODE_NETWORK | NODE_WITNESS},
+        /*local_services=*/ServiceFlags{NODE_NETWORK | NODE_WITNESS},
+        /*version=*/PROTOCOL_VERSION,
+        /*relay_txs=*/true);
+    BOOST_REQUIRE(ping_nonce_sent != 0);
+
+    auto time_elapsed = 1s;
+    SetMockTime(GetMockTime() + time_elapsed);
+    // No pong response has been received and current ping is outstanding.
+    CheckPingTimes(std::chrono::microseconds::max(), 0us, time_elapsed);
+
+    CSerializedNetMsg pong_msg;
+
+    BOOST_TEST_MESSAGE("Receiving a PONG without nonce cancels our PING");
+    {
+        ASSERT_DEBUG_LOG("Short payload");
+        pong_msg = CNetMsgMaker{PROTOCOL_VERSION}.Make(NetMsgType::PONG);
+        ReceiveAndProcessMessage(pong_msg);
+    }
+    // Ping metrics have not been updated and there is no ping outstanding.
+    CheckPingTimes(std::chrono::microseconds::max(), 0us, 0us);
+
+    BOOST_TEST_MESSAGE("Receiving an unrequested PONG is logged and ignored");
+    {
+        ASSERT_DEBUG_LOG("Unsolicited pong without ping");
+        pong_msg = CNetMsgMaker{PROTOCOL_VERSION}.Make(NetMsgType::PONG, /*nonce=*/(uint64_t)0);
+        ReceiveAndProcessMessage(pong_msg);
+    }
+    // Ping metrics have not been updated and there is no ping outstanding.
+    CheckPingTimes(std::chrono::microseconds::max(), 0us, 0us);
+
+    SendPing();
+
+    BOOST_TEST_MESSAGE("Receiving a PONG with the wrong nonce does not cancel our PING");
+    {
+        ASSERT_DEBUG_LOG("Nonce mismatch");
+        pong_msg = CNetMsgMaker{PROTOCOL_VERSION}.Make(NetMsgType::PONG, /*nonce=*/ping_nonce_sent + 1);
+        ReceiveAndProcessMessage(pong_msg);
+    }
+    // Ping metrics have not been updated and there is an outstanding ping.
+    time_elapsed = 5s;
+    SetMockTime(GetMockTime() + time_elapsed);
+    CheckPingTimes(std::chrono::microseconds::max(), 0us, time_elapsed);
+
+    BOOST_TEST_MESSAGE("Receiving a PONG with nonce=0 cancels our PING");
+    {
+        ASSERT_DEBUG_LOG("Nonce zero");
+        pong_msg = CNetMsgMaker{PROTOCOL_VERSION}.Make(NetMsgType::PONG, /*nonce=*/(uint64_t)0);
+        ReceiveAndProcessMessage(pong_msg);
+    }
+    // Ping metrics have not been updated and there is no ping outstanding.
+    CheckPingTimes(std::chrono::microseconds::max(), 0us, 0us);
+
+    SendPing();
+
+    time_elapsed = 5s;
+    SetMockTime(GetMockTime() + time_elapsed);
+
+    BOOST_TEST_MESSAGE("Receiving a PONG with the correct nonce cancels our PING");
+    pong_msg = CNetMsgMaker{PROTOCOL_VERSION}.Make(NetMsgType::PONG, ping_nonce_sent);
+    ReceiveAndProcessMessage(pong_msg);
+    // Ping metrics have been updated and there is no ping outstanding.
+    CheckPingTimes(time_elapsed, time_elapsed, 0us);
+
+    peerman.FinalizeNode(outbound_peer);
+
+    CaptureMessage = CaptureMessageOrig;
+    m_node.args->ForceSetArg("-capturemessages", "0");
+    // PeerManager::ProcessMessage() calls AddTimeData() which changes the internal state
+    // in timedata.cpp and later confuses the test "timedata_tests/addtimedata". Thus reset
+    // that state as it was before our test was run.
+    TestOnlyResetTimeData();
+}
+
 BOOST_AUTO_TEST_SUITE_END()