diff --git a/ci/checks/classify_merge_profile.py b/ci/checks/classify_merge_profile.py
index f00e503cbc..af6d234960 100755
--- a/ci/checks/classify_merge_profile.py
+++ b/ci/checks/classify_merge_profile.py
@@ -73,6 +73,7 @@
         "src/test/CMakeLists.txt",
         "src/test/fuzz/CMakeLists.txt",
         "src/util/CMakeLists.txt",
+        "test/CMakeLists.txt",
         # The jobs and the gate: this classifier, the workflows that run it and
         # the PQ jobs, the scripts and evidence check of those jobs, and the
         # tests of that wiring.
diff --git a/ci/checks/test_classify_merge_profile.py b/ci/checks/test_classify_merge_profile.py
index 917059be4f..4fdb90d35c 100755
--- a/ci/checks/test_classify_merge_profile.py
+++ b/ci/checks/test_classify_merge_profile.py
@@ -273,6 +273,7 @@ def test_pq_unit_jobs_required_for_mlkem_and_transport_paths(self) -> None:
             "src/test/CMakeLists.txt",
             "src/test/fuzz/CMakeLists.txt",
             "src/bench/CMakeLists.txt",
+            "test/CMakeLists.txt",
             "cmake/bitcoin-build-config.h.in",
             # Gate and CI wiring, and its tests.
             ".github/workflows/ci.yml",
diff --git a/doc/rpc/annotations/v30.2-delta.yml b/doc/rpc/annotations/v30.2-delta.yml
index 1bc02b5f77..2a93e0963b 100644
--- a/doc/rpc/annotations/v30.2-delta.yml
+++ b/doc/rpc/annotations/v30.2-delta.yml
@@ -25,6 +25,31 @@
         "Lane-specific estimates filter which blocks contribute work while using the same active-chain elapsed-time window as the all-lane estimate; they do not use a lane-local timestamp window."
       ]
     },
+    "getpqtransportinfo": {
+      "status_override": "new_since_v30_2",
+      "delta_summary": "Adds the hybrid post-quantum v2 transport (ML-KEM-1024 and ECDH) diagnostics RPC.",
+      "delta_notes": [
+        "This method does not exist in Bitcoin Core v30.2.",
+        "Every field is always present, and empty collections are [].",
+        "Counters count events since startup, not exclusive outcomes; they start over when instance_id changes."
+      ]
+    },
+    "getpeerinfo": {
+      "status_override": "semantic_changed_since_v30_2",
+      "delta_summary": "Adds transport_pq and transport_pq_status, and session_id is the hybrid session id for a hybrid post-quantum peer.",
+      "delta_notes": [
+        "transport_pq is true once the peer's key confirmation verified.",
+        "transport_pq_status is pending, hybrid, legacy_peer, fallback, off or v1. A connection that closes on a hybrid failure reports pending until it is removed.",
+        "transport_protocol_type keeps its values: detecting until the handshake completes, then v2."
+      ]
+    },
+    "getnetworkinfo": {
+      "status_override": "surface_changed_since_v30_2",
+      "delta_summary": "Adds connections_pq, the number of hybrid post-quantum connections.",
+      "delta_notes": [
+        "connections_pq counts transport_pq over the same peers getpeerinfo lists."
+      ]
+    },
     "getmininginfo": {
       "status_override": "semantic_changed_since_v30_2",
       "delta_summary": "networkhashps is the default total qbit chainwork hashrate estimate, and next is the permissionless/native candidate.",
diff --git a/src/bitcoin-cli.cpp b/src/bitcoin-cli.cpp
index a03bd5663c..d7020a75a1 100644
--- a/src/bitcoin-cli.cpp
+++ b/src/bitcoin-cli.cpp
@@ -407,6 +407,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
         std::string age;
         std::string services;
         std::string transport_protocol_type;
+        bool is_transport_pq;
         double min_ping;
         double ping;
         int64_t addr_processed;
@@ -555,10 +556,12 @@ class NetinfoRequestHandler : public BaseRequestHandler
                 const std::string services{FormatServices(services_names)};
                 const std::string sub_version{peer["subver"].isNull() ? "" : peer["subver"].get_str()};
                 const std::string transport{peer["transport_protocol_type"].isNull() ? "v1" : peer["transport_protocol_type"].get_str()};
+                // A server without hybrid post-quantum transport, such as v1.0.0, has no transport_pq.
+                const bool is_transport_pq{peer["transport_pq"].isNull() ? false : peer["transport_pq"].get_bool()};
                 const bool is_addr_relay_enabled{peer["addr_relay_enabled"].isNull() ? false : peer["addr_relay_enabled"].get_bool()};
                 const bool is_bip152_hb_from{peer["bip152_hb_from"].isNull() ? false : peer["bip152_hb_from"].get_bool()};
                 const bool is_bip152_hb_to{peer["bip152_hb_to"].isNull() ? false : peer["bip152_hb_to"].get_bool()};
-                m_peers.push_back({addr, sub_version, conn_type, NETWORK_SHORT_NAMES[network_id], age, services, transport, min_ping, ping, addr_processed, addr_rate_limited, last_blck, last_recv, last_send, last_trxn, peer_id, mapped_as, version, is_addr_relay_enabled, is_bip152_hb_from, is_bip152_hb_to, is_outbound, is_tx_relay});
+                m_peers.push_back({addr, sub_version, conn_type, NETWORK_SHORT_NAMES[network_id], age, services, transport, is_transport_pq, min_ping, ping, addr_processed, addr_rate_limited, last_blck, last_recv, last_send, last_trxn, peer_id, mapped_as, version, is_addr_relay_enabled, is_bip152_hb_from, is_bip152_hb_to, is_outbound, is_tx_relay});
                 m_max_addr_length = std::max(addr.length() + 1, m_max_addr_length);
                 m_max_addr_processed_length = std::max(ToString(addr_processed).length(), m_max_addr_processed_length);
                 m_max_addr_rate_limited_length = std::max(ToString(addr_rate_limited).length(), m_max_addr_rate_limited_length);
@@ -593,7 +596,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
                     peer.network,
                     m_max_services_length, // variable spacing
                     peer.services,
-                    (peer.transport_protocol_type.size() == 2 && peer.transport_protocol_type[0] == 'v') ? peer.transport_protocol_type[1] : ' ',
+                    peer.is_transport_pq ? "2p" : (peer.transport_protocol_type.size() == 2 && peer.transport_protocol_type[0] == 'v') ? peer.transport_protocol_type.substr(1) : "",
                     PingTimeToString(peer.min_ping),
                     PingTimeToString(peer.ping),
                     peer.last_send ? ToString(time_now - peer.last_send) : "",
@@ -720,6 +723,7 @@ class NetinfoRequestHandler : public BaseRequestHandler
         "           \"2\" - P2P_V2: peer supports version 2 P2P transport protocol, as defined in BIP 324\n"
         "           \"u\" - UNKNOWN: unrecognized bit flag\n"
         "  v        Version of transport protocol used for the connection\n"
+        "           \"2p\" - v2 with hybrid post-quantum session keys (getpeerinfo \"transport_pq\" is true)\n"
         "  mping    Minimum observed ping time, in milliseconds (ms)\n"
         "  ping     Last observed ping time, in milliseconds (ms)\n"
         "  send     Time since last message sent to the peer, in seconds\n"
diff --git a/src/common/args.cpp b/src/common/args.cpp
index ce0b414cca..dbd5604ec2 100644
--- a/src/common/args.cpp
+++ b/src/common/args.cpp
@@ -745,6 +745,8 @@ const std::vector<std::string> TEST_OPTIONS_DOC{
     "reindex_after_failure_noninteractive_yes (When asked for a reindex after failure interactively, simulate as-if answered with 'yes')",
     "bip94 (enforce BIP94 consensus rules)",
     "disable_witness_pruning (disable witness pruning in regtest)",
+    "pq_fail_first_packet (corrupt this node's ML-KEM shared secret on every hybrid post-quantum v2 handshake, so the peer's key confirmation fails)",
+    "mlkem_portable (use the portable ML-KEM-1024 code instead of native code)",
 };
 
 bool HasTestOption(const ArgsManager& args, const std::string& test_option)
diff --git a/src/init.cpp b/src/init.cpp
index 297a4f2824..4dba9c2790 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -20,6 +20,7 @@
 #include <common/system.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
+#include <crypto/mlkem.h>
 #include <deploymentstatus.h>
 #include <hash.h>
 #include <httprpc.h>
@@ -565,6 +566,7 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
     argsman.AddArg("-i2pacceptincoming", strprintf("Whether to accept inbound I2P connections (default: %i). Ignored if -i2psam is not set. Listening for inbound I2P connections is done through the SAM proxy, not by binding to a local address and port.", DEFAULT_I2P_ACCEPT_INCOMING), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-onlynet=<net>", "Make automatic outbound connections only to network <net> (" + Join(GetNetworkNames(), ", ") + "). Inbound and manual connections are not affected by this option. It can be specified multiple times to allow multiple networks.", ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-v2transport", strprintf("Support v2 transport (default: %u)", DEFAULT_V2_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
+    argsman.AddArg("-v2pqtransport", strprintf("Support hybrid post-quantum key exchange (ML-KEM-1024) in v2 transport. Has no effect with -v2transport=0. A non-numeric value, or a double negative such as -nov2pqtransport=0, warns at startup and states how it was read (default: %u)", DEFAULT_V2_PQ_TRANSPORT), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peerbloomfilters", strprintf("Support filtering of blocks and transaction with bloom filters (default: %u)", DEFAULT_PEERBLOOMFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-peerblockfilters", strprintf("Serve compact block filters to peers per BIP 157 (default: %u)", DEFAULT_PEERBLOCKFILTERS), ArgsManager::ALLOW_ANY, OptionsCategory::CONNECTION);
     argsman.AddArg("-txreconciliation", strprintf("Enable transaction reconciliations per BIP 330 (default: %d)", DEFAULT_TXRECONCILIATION_ENABLE), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::CONNECTION);
@@ -649,6 +651,7 @@ void SetupServerArgs(ArgsManager& argsman, bool can_listen_ipc)
     argsman.AddArg("-limitdescendantsize=<n>", strprintf("Do not accept transactions if any ancestor would have more than <n> kilobytes of in-mempool descendants (default: %u).", DEFAULT_DESCENDANT_SIZE_LIMIT_KVB), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-test=<option>", "Pass a test-only option. Options include : " + Join(TEST_OPTIONS_DOC, ", ") + ".", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-capturemessages", "Capture all P2P messages to disk", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
+    argsman.AddArg("-mlkemportable", "Use the portable ML-KEM-1024 code instead of native code, in case native code misbehaves on this CPU. A non-numeric value, or a double negative such as -nomlkemportable=0, warns at startup and states how it was read (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-mocktime=<n>", "Replace actual time with " + UNIX_EPOCH_TIME + " (default: 0)", ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-maxsigcachesize=<n>", strprintf("Limit sum of signature cache and script execution cache sizes to <n> MiB (default: %u)", DEFAULT_VALIDATION_CACHE_BYTES >> 20), ArgsManager::ALLOW_ANY | ArgsManager::DEBUG_ONLY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-maxtipage=<n>",
@@ -847,6 +850,69 @@ int available_fds;
 ServiceFlags g_local_services = ServiceFlags(NODE_NETWORK_LIMITED | NODE_WITNESS);
 int64_t peer_connect_timeout;
 std::set<BlockFilterType> g_enabled_filter_types;
+//! Set once by AppInitParameterInteraction(), for the startup line and the connection manager.
+PQTransportConfig g_pq_transport_config;
+//! Set once by AppInitParameterInteraction(): -mlkemportable or -test=mlkem_portable.
+bool g_mlkem_force_portable{false};
+
+/**
+ * How a boolean setting's text relates to what it is read as. Booleans are read as integers
+ * (InterpretBool()), so a string that isn't one completely, under the same whitespace and sign
+ * rules, is NON_NUMERIC: -X=true is read as 0, and -X=1abc or an overflowing number as 1. An empty
+ * value means 1. ArgsManager keeps a negated setting only as a bool, false for -noX and -noX=1, and
+ * true for a DOUBLE_NEGATIVE, -noX given 0 or any non-numeric value, which switches X on. Its text
+ * is gone, so -noX=1abc, read as 0 like -noX, is PLAIN.
+ */
+enum class BoolSettingText { PLAIN, NON_NUMERIC, DOUBLE_NEGATIVE };
+
+BoolSettingText GetBoolSettingText(const common::SettingsValue& value)
+{
+    if (value.isBool()) return value.get_bool() ? BoolSettingText::DOUBLE_NEGATIVE : BoolSettingText::PLAIN;
+    if (!value.isStr() || value.get_str().empty()) return BoolSettingText::PLAIN;
+    std::string_view number{util::TrimStringView(value.get_str())};
+    if (number.starts_with('+') && !number.starts_with("+-")) number.remove_prefix(1);
+    return ToIntegral<int>(number) ? BoolSettingText::PLAIN : BoolSettingText::NON_NUMERIC;
+}
+
+/** The warning for the boolean option -name when its setting's text doesn't say what it is read
+ *  as: the value given, if ArgsManager kept it, what it was read as, and the effect. */
+std::optional<bilingual_str> BoolSettingWarning(const std::string& name, const common::SettingsValue& value, bool read_as,
+                                                const bilingual_str& effect)
+{
+    switch (GetBoolSettingText(value)) {
+    case BoolSettingText::PLAIN:
+        return std::nullopt;
+    case BoolSettingText::NON_NUMERIC:
+        return strprintf(_("-%s=%s is not a number and was read as -%s=%d: %s. Use -%s=1 or -%s=0."),
+                         name, value.get_str(), name, read_as, effect, name, name);
+    case BoolSettingText::DOUBLE_NEGATIVE:
+        return strprintf(_("-no%s was given 0 or a non-numeric value, so it was read as -%s=1: %s. Use -%s=0 to switch it off."),
+                         name, name, effect, name);
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
+/** The hybrid post-quantum v2 transport configuration of the effective settings, and the warnings
+ *  they need. */
+PQTransportConfig GetPQTransportConfig(const ArgsManager& args, std::vector<bilingual_str>& warnings)
+{
+    const common::SettingsValue pq_setting{args.GetSetting("-v2pqtransport")};
+    const std::optional<bool> pq_explicit{SettingToBool(pq_setting)};
+    const PQTransportConfig config{
+        .v2_enabled = args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT),
+        .pq_requested = pq_explicit.value_or(DEFAULT_V2_PQ_TRANSPORT),
+        .fail_first_packet = HasTestOption(args, "pq_fail_first_packet"),
+    };
+    if (auto warning{BoolSettingWarning("v2pqtransport", pq_setting, config.pq_requested,
+                                        config.Enabled() ? _("hybrid transport is ON") : _("hybrid transport is OFF"))}) {
+        warnings.push_back(std::move(*warning));
+    }
+    // Only an explicit request warns, never the default.
+    if (pq_explicit == true && !config.v2_enabled) {
+        warnings.push_back(_("-v2pqtransport=1 has no effect because -v2transport=0. Set -v2transport=1 to use hybrid post-quantum v2 transport."));
+    }
+    return config;
+}
 
 } // namespace
 
@@ -967,8 +1033,24 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         }
     }
 
+    // The v2 transport configuration: the hybrid post-quantum key exchange's warnings, startup line,
+    // connections and RPC all use this one.
+    std::vector<bilingual_str> pq_warnings;
+    g_pq_transport_config = GetPQTransportConfig(args, pq_warnings);
+    for (const bilingual_str& warning : pq_warnings) InitWarning(warning);
+
+    // The ML-KEM-1024 code, selected before any networking object exists (AppInitMain()).
+    const common::SettingsValue portable_setting{args.GetSetting("-mlkemportable")};
+    const bool portable{SettingToBool(portable_setting).value_or(false)};
+    g_mlkem_force_portable = portable || HasTestOption(args, "mlkem_portable");
+    if (auto warning{BoolSettingWarning("mlkemportable", portable_setting, portable,
+                                        g_mlkem_force_portable ? _("ML-KEM-1024 uses portable code") :
+                                                                 _("ML-KEM-1024 uses native code where the CPU supports it"))}) {
+        InitWarning(*warning);
+    }
+
     // Signal NODE_P2P_V2 if BIP324 v2 transport is enabled.
-    if (args.GetBoolArg("-v2transport", DEFAULT_V2_TRANSPORT)) {
+    if (g_pq_transport_config.v2_enabled) {
         g_local_services = ServiceFlags(g_local_services | NODE_P2P_V2);
     }
 
@@ -1620,6 +1702,17 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         node.addrman = std::move(*addrman);
     }
 
+    // Select the ML-KEM-1024 code before any networking object exists, and name it.
+    mlkem::InitializeRuntime(/*force_portable=*/g_mlkem_force_portable);
+    {
+        const mlkem::BackendNames backends{mlkem::GetBackendNames()};
+        LogInfo("v2 pq: %s arith=%s keccak=%s",
+                !g_pq_transport_config.v2_enabled    ? "disabled (-v2transport=0)" :
+                !g_pq_transport_config.pq_requested ? "disabled (-v2pqtransport=0)" :
+                                                      "enabled",
+                backends.arith, backends.keccak);
+    }
+
     FastRandomContext rng;
     assert(!node.banman);
     node.banman = std::make_unique<BanMan>(args.GetDataDirNet() / "banlist", &uiInterface, args.GetIntArg("-bantime", DEFAULT_MISBEHAVING_BANTIME));
@@ -2113,6 +2206,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     connOptions.m_peer_connect_timeout = peer_connect_timeout;
     connOptions.whitelist_forcerelay = args.GetBoolArg("-whitelistforcerelay", DEFAULT_WHITELISTFORCERELAY);
     connOptions.whitelist_relay = args.GetBoolArg("-whitelistrelay", DEFAULT_WHITELISTRELAY);
+    connOptions.m_pq = g_pq_transport_config;
 
     // Port to bind to if `-bind=addr` is provided without a `:port` suffix.
     const uint16_t default_bind_port =
diff --git a/src/net.cpp b/src/net.cpp
index 256b99dc2e..3cbe507887 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -556,7 +556,7 @@ CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, bool fCo
                                     .recv_flood_size = nReceiveFloodSize,
                                     .use_v2transport = use_v2transport,
                                     .is_archive_connection = is_archive_connection,
-                                    .pq = {.mode = pq_mode},
+                                    .pq = {.mode = pq_mode, .corrupt_shared_secret = m_pq_config.fail_first_packet},
                                     .pq_endpoint = std::move(pq_endpoint),
                                 });
         pnode->AddRef();
@@ -672,6 +672,8 @@ void CNode::CopyStats(CNodeStats& stats)
         Transport::Info info = m_transport->GetInfo();
         stats.m_transport_type = info.transport_type;
         if (info.session_id) stats.m_session_id = HexStr(*info.session_id);
+        stats.m_transport_pq = info.transport_pq;
+        stats.m_transport_pq_status = info.transport_pq_status;
     }
     X(m_permission_flags);
 
@@ -2178,7 +2180,9 @@ void CConnman::CreateNodeFromAcceptedSocket(std::unique_ptr<Sock>&& sock,
                                  .prefer_evict = discouraged,
                                  .recv_flood_size = nReceiveFloodSize,
                                  .use_v2transport = use_v2transport,
-                                 .pq = {.mode = m_pq_mode, .offer_gate = {.allow = &CConnman::AllowPQOffer, .context = this}},
+                                 .pq = {.mode = m_pq_mode,
+                                        .corrupt_shared_secret = m_pq_config.fail_first_packet,
+                                        .offer_gate = {.allow = &CConnman::AllowPQOffer, .context = this}},
                                  // The actual remote address and source port.
                                  .pq_endpoint = addr,
                              });
@@ -2260,6 +2264,19 @@ std::string_view PQOutcomeString(PQOutcome outcome) noexcept
     assert(false);
 }
 
+std::string_view PQStatusString(PQStatus status) noexcept
+{
+    switch (status) {
+    case PQStatus::V1: return "v1";
+    case PQStatus::OFF: return "off";
+    case PQStatus::PENDING: return "pending";
+    case PQStatus::HYBRID: return "hybrid";
+    case PQStatus::LEGACY_PEER: return "legacy_peer";
+    case PQStatus::FALLBACK: return "fallback";
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
 namespace {
 /** The index of a direction in the hybrid negotiation counters and failure rings. */
 size_t PQDirection(bool inbound) { return inbound ? 0 : 1; }
@@ -2609,9 +2626,12 @@ void CConnman::LogPQOutcome(const CNode& node, const PQLogLine& line) const
 void CConnman::LogPQLocalFault() const
 {
     const auto backends{mlkem::GetBackendNames()};
+    // -mlkemportable is the remedy only while native code runs.
+    const bool native{backends.arith != "portable" || backends.keccak != "portable"};
     LogWarning("v2 pq: local_fault arith=%s keccak=%s: hybrid handshakes failed with %u distinct endpoints and none succeeded "
-               "since startup, so this node's own ML-KEM code may be at fault.",
-               backends.arith, backends.keccak, PQ_LOCAL_FAULT_THRESHOLD);
+               "since startup, so this node's own ML-KEM code may be at fault.%s",
+               backends.arith, backends.keccak, PQ_LOCAL_FAULT_THRESHOLD,
+               native ? " Restart with -mlkemportable to use the portable implementation." : "");
 }
 
 PQTransportStats CConnman::GetPQTransportStats() const
@@ -4623,10 +4643,10 @@ ServiceFlags CConnman::GetLocalServices() const
     return m_local_services;
 }
 
-static std::unique_ptr<Transport> MakeTransport(NodeId id, bool use_v2transport, bool inbound, const V2PQOptions& pq) noexcept
+static std::unique_ptr<Transport> MakeTransport(NodeId id, const CNodeOptions& options, bool inbound) noexcept
 {
-    if (use_v2transport) {
-        return std::make_unique<V2Transport>(id, /*initiating=*/!inbound, pq);
+    if (options.use_v2transport) {
+        return std::make_unique<V2Transport>(id, /*initiating=*/!inbound, options.pq);
     } else {
         return std::make_unique<V1Transport>(id);
     }
@@ -4642,7 +4662,7 @@ CNode::CNode(NodeId idIn,
              ConnectionType conn_type_in,
              bool inbound_onion,
              CNodeOptions&& node_opts)
-    : m_transport{MakeTransport(idIn, node_opts.use_v2transport, conn_type_in == ConnectionType::INBOUND, node_opts.pq)},
+    : m_transport{MakeTransport(idIn, node_opts, conn_type_in == ConnectionType::INBOUND)},
       m_permission_flags{node_opts.permission_flags},
       m_sock{sock},
       m_connected{GetTime<std::chrono::seconds>()},
diff --git a/src/net.h b/src/net.h
index 92ec68797b..d21f304bab 100644
--- a/src/net.h
+++ b/src/net.h
@@ -102,6 +102,8 @@ static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
 static const size_t DEFAULT_MAXSENDBUFFER    = 1 * 1000;
 
 static constexpr bool DEFAULT_V2_TRANSPORT{true};
+/** -v2pqtransport default: off until the default-on change of #184 part 9. */
+static constexpr bool DEFAULT_V2_PQ_TRANSPORT{false};
 
 typedef int64_t NodeId;
 
@@ -231,8 +233,12 @@ class CNodeStats
     bool m_is_archive_connection;
     /** Transport protocol type. */
     TransportProtocolType m_transport_type;
-    /** BIP324 session id string in hex, if any. */
+    /** BIP324 session id string in hex, if any: the hybrid one if m_transport_pq. */
     std::string m_session_id;
+    /** Whether the session keys are hybrid post-quantum: the peer's key confirmation verified. */
+    bool m_transport_pq{false};
+    /** The hybrid post-quantum negotiation's status. */
+    PQStatus m_transport_pq_status{PQStatus::OFF};
 };
 
 
@@ -833,6 +839,9 @@ enum class PQOutcome : uint8_t {
 
 std::string_view PQOutcomeString(PQOutcome outcome) noexcept;
 
+/** The getpeerinfo transport_pq_status token of a status. */
+std::string_view PQStatusString(PQStatus status) noexcept;
+
 /** Hybrid negotiation event counts of one direction. They count events, not exclusive final
  *  states: a switch whose confirmation then fails counts switched and first_packet_failed. */
 template <typename T>
@@ -960,6 +969,21 @@ struct PQTransportStats {
     PQLoadSheddingStats load_shedding;
 };
 
+/**
+ * The hybrid post-quantum v2 transport configuration: computed once at startup from the effective
+ * -v2transport, -v2pqtransport and -test settings, and used unchanged for the startup warnings,
+ * the startup line, every new connection and RPC.
+ */
+struct PQTransportConfig {
+    //! -v2transport.
+    bool v2_enabled{false};
+    //! -v2pqtransport, which has no effect without v2_enabled.
+    bool pq_requested{false};
+    //! -test=pq_fail_first_packet: corrupt the local ML-KEM shared secret of every hybrid handshake.
+    bool fail_first_packet{false};
+    bool Enabled() const noexcept { return v2_enabled && pq_requested; }
+};
+
 struct CNodeOptions
 {
     NetPermissionFlags permission_flags = NetPermissionFlags::None;
@@ -1412,6 +1436,8 @@ class CConnman
         bool whitelist_relay = DEFAULT_WHITELISTRELAY;
         //! Inbound offer load shedding threshold (unit tests and the flood lab).
         uint64_t pq_shed_threshold_per_s{DEFAULT_PQ_SHED_THRESHOLD_PER_S};
+        //! The hybrid post-quantum v2 transport configuration; off unless set.
+        PQTransportConfig m_pq{};
     };
 
     void Init(const Options& connOptions) EXCLUSIVE_LOCKS_REQUIRED(!m_added_nodes_mutex, !m_total_bytes_sent_mutex, !m_pq_shed_mutex)
@@ -1451,6 +1477,8 @@ class CConnman
             // At least 1: a threshold of 0 would shed every offer and never stop.
             m_pq_shed_threshold = std::max<uint64_t>(connOptions.pq_shed_threshold_per_s, 1);
         }
+        m_pq_config = connOptions.m_pq;
+        m_pq_mode = m_pq_config.Enabled() ? PQMode::NEGOTIATE : PQMode::OFF;
     }
 
     CConnman(uint64_t seed0, uint64_t seed1, AddrMan& addrman, const NetGroupManager& netgroupman,
@@ -1620,6 +1648,9 @@ class CConnman
     /** An owning copy of the hybrid transport counters, failure rings and endpoint history. */
     PQTransportStats GetPQTransportStats() const EXCLUSIVE_LOCKS_REQUIRED(!m_pq_mutex, !m_pq_shed_mutex);
 
+    /** The hybrid post-quantum v2 transport configuration, as Init() received it. */
+    const PQTransportConfig& GetPQTransportConfig() const noexcept { return m_pq_config; }
+
     /** Whether new outbound connections to endpoint run plain v2, because repeated hybrid
      *  failures put it in the fallback set. Ends a window that expired. */
     bool IsPQFallback(const PQEndpointKey& endpoint, NodeSeconds now) EXCLUSIVE_LOCKS_REQUIRED(!m_pq_mutex);
@@ -2090,8 +2121,10 @@ class CConnman
     /** Warn that this node's own ML-KEM code may be at fault. */
     void LogPQLocalFault() const;
 
-    /** The hybrid negotiation mode of new v2 connections. Off until the option sets it (part 6);
-     *  set before the connection threads start. */
+    /** The hybrid post-quantum v2 transport configuration (Options::m_pq), and the negotiation
+     *  mode of new v2 connections it gives. Both are set by Init(), before the connection
+     *  threads start, and never change afterwards. */
+    PQTransportConfig m_pq_config{};
     PQMode m_pq_mode{PQMode::OFF};
 
     mutable Mutex m_pq_mutex;
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index d6d2be7b39..7caa70b502 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -493,7 +493,9 @@ RPCConsole::RPCConsole(interfaces::Node& node, const PlatformStyle *_platformSty
         //: Explanatory text for v1 transport type.
         tr("v1: unencrypted, plaintext transport protocol"),
         //: Explanatory text for v2 transport type.
-        tr("v2: BIP324 encrypted transport protocol")};
+        tr("v2: BIP324 encrypted transport protocol"),
+        //: Explanatory text for the v2 transport type with hybrid post-quantum session keys.
+        tr("v2 (hybrid post-quantum): v2 with session keys from both ECDH and ML-KEM-1024")};
     const QString transport_types_list{"<ul><li>" + Join(TRANSPORT_TYPE_DOC, QString("</li><li>")) + "</li></ul>"};
     ui->peerTransportTypeLabel->setToolTip(ui->peerTransportTypeLabel->toolTip().arg(transport_types_list));
     const QString hb_list{"<ul><li>\""
@@ -1179,7 +1181,10 @@ void RPCConsole::updateDetailWidget()
         ui->peerSubversion->setText(QString::fromStdString(stats->nodeStats.cleanSubVer));
     }
     ui->peerConnectionType->setText(GUIUtil::ConnectionTypeToQString(stats->nodeStats.m_conn_type, /*prepend_direction=*/true));
-    ui->peerTransportType->setText(QString::fromStdString(TransportTypeAsString(stats->nodeStats.m_transport_type)));
+    ui->peerTransportType->setText(stats->nodeStats.m_transport_pq ?
+                                       //: Transport type of a v2 peer whose session keys are hybrid post-quantum.
+                                       tr("v2 (hybrid post-quantum)") :
+                                       QString::fromStdString(TransportTypeAsString(stats->nodeStats.m_transport_type)));
     if (stats->nodeStats.m_transport_type == TransportProtocolType::V2) {
         ui->peerSessionIdLabel->setVisible(true);
         ui->peerSessionId->setVisible(true);
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
index 334e7890d8..5d3fb0eb4a 100644
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -10,6 +10,7 @@
 #include <chainparams.h>
 #include <clientversion.h>
 #include <core_io.h>
+#include <crypto/mlkem.h>
 #include <net_permissions.h>
 #include <net_processing.h>
 #include <net_types.h>
@@ -36,6 +37,7 @@
 #include <optional>
 #include <stdexcept>
 #include <string>
+#include <variant>
 #include <vector>
 
 using node::NodeContext;
@@ -57,6 +59,15 @@ const std::vector<std::string> TRANSPORT_TYPE_DOC{
     "v2 (BIP324 encrypted transport protocol)"
 };
 
+const std::vector<std::string> PQ_STATUS_DOC{
+    "pending (negotiating, or closing: a connection that closes on any hybrid failure reports pending until it is removed)",
+    "hybrid (the peer's key confirmation verified: the session keys are hybrid)",
+    "legacy_peer (the peer's version packet carried no usable offer or accept: ECDH keys)",
+    "fallback (plain v2 to an endpoint in the fallback set after repeated hybrid failures)",
+    "off (plain v2: -v2pqtransport is off, the offer was shed, or a local ML-KEM fault happened before anything was committed)",
+    "v1 (v1 transport protocol)"
+};
+
 static RPCHelpMan getconnectioncount()
 {
     return RPCHelpMan{
@@ -117,6 +128,32 @@ static UniValue GetServicesNames(ServiceFlags services)
     return servicesNames;
 }
 
+/** A peer getpeerinfo lists, with its node state. */
+struct ListedPeer {
+    CNodeStats stats;
+    CNodeStateStats statestats;
+};
+
+/** The peers getpeerinfo lists; getnetworkinfo counts over the same ones. */
+static std::vector<ListedPeer> GetListedPeers(const CConnman& connman, const PeerManager& peerman)
+{
+    std::vector<CNodeStats> vstats;
+    connman.GetNodeStats(vstats);
+    std::vector<ListedPeer> peers;
+    peers.reserve(vstats.size());
+    for (CNodeStats& stats : vstats) {
+        CNodeStateStats statestats;
+        // GetNodeStateStats() requires the existence of a CNodeState and a Peer object
+        // to succeed for this peer. These are created at connection initialisation and
+        // exist for the duration of the connection - except if there is a race where the
+        // peer got disconnected in between the GetNodeStats() and the GetNodeStateStats()
+        // calls. In this case, the peer doesn't need to be reported here.
+        if (!peerman.GetNodeStateStats(stats.nodeid, statestats)) continue;
+        peers.push_back({std::move(stats), std::move(statestats)});
+    }
+    return peers;
+}
+
 static RPCHelpMan getpeerinfo()
 {
     return RPCHelpMan{
@@ -191,7 +228,11 @@ static RPCHelpMan getpeerinfo()
                                                               "Please note this output is unlikely to be stable in upcoming releases as we iterate to\n"
                                                               "best capture connection behaviors."},
                     {RPCResult::Type::STR, "transport_protocol_type", "Type of transport protocol: \n" + Join(TRANSPORT_TYPE_DOC, ",\n") + ".\n"},
-                    {RPCResult::Type::STR, "session_id", "The session ID for this connection, or \"\" if there is none (\"v2\" transport protocol only).\n"},
+                    {RPCResult::Type::STR, "session_id", "The session ID for this connection, or \"\" if there is none (\"v2\" transport protocol only).\n"
+                                                         "With hybrid post-quantum session keys (transport_pq), the hybrid session ID.\n"},
+                    {RPCResult::Type::BOOL, "transport_pq", "Whether the session keys are hybrid post-quantum (ML-KEM-1024 and ECDH): true once the peer's key confirmation verified"},
+                    {RPCResult::Type::STR, "transport_pq_status", "Status of the hybrid post-quantum key exchange: \n" + Join(PQ_STATUS_DOC, ",\n") + ".\n"
+                                                                  "There is no failed status: every hybrid negotiation failure that closes the connection reports pending until the peer is removed.\n"},
                 }},
             }},
         },
@@ -205,23 +246,10 @@ static RPCHelpMan getpeerinfo()
     const CConnman& connman = EnsureConnman(node);
     const PeerManager& peerman = EnsurePeerman(node);
 
-    std::vector<CNodeStats> vstats;
-    connman.GetNodeStats(vstats);
-
     UniValue ret(UniValue::VARR);
 
-    for (const CNodeStats& stats : vstats) {
+    for (const auto& [stats, statestats] : GetListedPeers(connman, peerman)) {
         UniValue obj(UniValue::VOBJ);
-        CNodeStateStats statestats;
-        bool fStateStats = peerman.GetNodeStateStats(stats.nodeid, statestats);
-        // GetNodeStateStats() requires the existence of a CNodeState and a Peer object
-        // to succeed for this peer. These are created at connection initialisation and
-        // exist for the duration of the connection - except if there is a race where the
-        // peer got disconnected in between the GetNodeStats() and the GetNodeStateStats()
-        // calls. In this case, the peer doesn't need to be reported here.
-        if (!fStateStats) {
-            continue;
-        }
         obj.pushKV("id", stats.nodeid);
         obj.pushKV("addr", stats.m_addr_name);
         if (stats.addrBind.IsValid()) {
@@ -298,6 +326,8 @@ static RPCHelpMan getpeerinfo()
         obj.pushKV("connection_type", ConnectionTypeAsString(stats.m_conn_type));
         obj.pushKV("transport_protocol_type", TransportTypeAsString(stats.m_transport_type));
         obj.pushKV("session_id", stats.m_session_id);
+        obj.pushKV("transport_pq", stats.m_transport_pq);
+        obj.pushKV("transport_pq_status", std::string{PQStatusString(stats.m_transport_pq_status)});
 
         ret.push_back(std::move(obj));
     }
@@ -792,6 +822,7 @@ static RPCHelpMan getnetworkinfo()
                         {RPCResult::Type::NUM, "connections", "the total number of connections"},
                         {RPCResult::Type::NUM, "connections_in", "the number of inbound connections"},
                         {RPCResult::Type::NUM, "connections_out", "the number of outbound connections"},
+                        {RPCResult::Type::NUM, "connections_pq", "the number of connections with hybrid post-quantum session keys: the peers getpeerinfo lists with transport_pq true"},
                         {RPCResult::Type::BOOL, "networkactive", "whether p2p networking is enabled"},
                         {RPCResult::Type::ARR, "networks", "information per network",
                         {
@@ -831,12 +862,19 @@ static RPCHelpMan getnetworkinfo()
                 },
         [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
 {
+    NodeContext& node = EnsureAnyNodeContext(request.context);
+    // Counted before cs_main is taken, as getpeerinfo lists the peers.
+    int connections_pq{0};
+    if (node.connman && node.peerman) {
+        for (const ListedPeer& peer : GetListedPeers(*node.connman, *node.peerman)) {
+            if (peer.stats.m_transport_pq) ++connections_pq;
+        }
+    }
     LOCK(cs_main);
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("version",       CLIENT_VERSION);
     obj.pushKV("subversion",    strSubVersion);
     obj.pushKV("protocolversion",PROTOCOL_VERSION);
-    NodeContext& node = EnsureAnyNodeContext(request.context);
     if (node.connman) {
         ServiceFlags services = node.connman->GetLocalServices();
         obj.pushKV("localservices", strprintf("%016x", services));
@@ -852,6 +890,7 @@ static RPCHelpMan getnetworkinfo()
         obj.pushKV("connections", node.connman->GetNodeCount(ConnectionDirection::Both));
         obj.pushKV("connections_in", node.connman->GetNodeCount(ConnectionDirection::In));
         obj.pushKV("connections_out", node.connman->GetNodeCount(ConnectionDirection::Out));
+        obj.pushKV("connections_pq", connections_pq);
     }
     obj.pushKV("networks",      GetNetworksInfo());
     if (node.mempool) {
@@ -1339,6 +1378,282 @@ static RPCHelpMan getrawaddrman()
     };
 }
 
+/** The getpqtransportinfo help of an endpoint. */
+static std::vector<RPCResult> PQEndpointDoc()
+{
+    return {
+        {RPCResult::Type::STR, "kind", "\"address\" (a resolved destination, or an inbound peer) or \"name_proxy\" (a hostname connected through a proxy that resolves it)"},
+        {RPCResult::Type::STR, "network", "ipv4, ipv6, onion, i2p, cjdns or name_proxy"},
+        {RPCResult::Type::STR, "address", "The canonical address, or the normalized hostname, without the port"},
+        {RPCResult::Type::NUM, "port", "The port; for an inbound peer, its source port"},
+    };
+}
+
+/** The getpqtransportinfo help of one direction's counters. */
+static std::vector<RPCResult> PQCountsDoc(bool inbound)
+{
+    std::vector<RPCResult> doc{
+        {RPCResult::Type::NUM, "switched", "Switches to hybrid keys, including those whose key confirmation then failed"},
+        {RPCResult::Type::NUM, "legacy_peer", "Peers whose version packet carried no usable offer or accept"},
+        {RPCResult::Type::NUM, "malformed_record", "Peers whose first hybrid record was malformed"},
+        {RPCResult::Type::NUM, "first_packet_failed", "Key confirmations of the peer that failed"},
+        {RPCResult::Type::NUM, "abandoned", "Offers whose initiator sent no authenticated version packet before the connection closed (only responders offer: 0 outbound)"},
+        {RPCResult::Type::NUM, "internal_error", "Local ML-KEM or cipher state errors"},
+    };
+    if (inbound) {
+        doc.emplace_back(RPCResult::Type::NUM, "shed", "Offers not made because of load shedding");
+    } else {
+        doc.emplace_back(RPCResult::Type::NUM, "closed_after_switch", "Connections the peer closed, or that timed out, after we switched and before its key confirmation verified");
+        doc.emplace_back(RPCResult::Type::NUM, "fallback", "Entries of an endpoint into the fallback set (not the plain v2 connections it gives)");
+    }
+    return doc;
+}
+
+/** The getpqtransportinfo help of one direction's failure ring. */
+static RPCResult PQRingDoc(const std::string& name, const std::string& description)
+{
+    return {RPCResult::Type::OBJ, name, description,
+        {
+            {RPCResult::Type::NUM, "last_sequence", "The sequence of the newest entry ever added (the first is 1), or 0 if none"},
+            {RPCResult::Type::NUM, "dropped", strprintf("How many entries were evicted to keep at most %u", PQ_FAILURE_RING_SIZE)},
+            {RPCResult::Type::ARR, "entries", "The most recent failures, oldest first",
+            {
+                {RPCResult::Type::OBJ, "", "",
+                {
+                    {RPCResult::Type::NUM, "sequence", "The entry's sequence in this ring"},
+                    {RPCResult::Type::NUM_TIME, "time", "The " + UNIX_EPOCH_TIME + " of the outcome"},
+                    {RPCResult::Type::OBJ, "endpoint", "The endpoint the outcome is accounted to", PQEndpointDoc()},
+                    {RPCResult::Type::STR, "direction", "\"inbound\" or \"outbound\""},
+                    {RPCResult::Type::STR, "connection_type", "The connection type, as in getpeerinfo"},
+                    {RPCResult::Type::NUM, "peer_id", "The peer index, as in getpeerinfo"},
+                    {RPCResult::Type::STR, "outcome", "legacy_peer, malformed_record, first_packet_failed, abandoned, closed_after_switch, fallback or internal_error"},
+                    {RPCResult::Type::STR, "reason", "The outcome's reason (see above)"},
+                }},
+            }},
+        }};
+}
+
+/** The network of an endpoint's address, as getpqtransportinfo names it. */
+static std::string PQEndpointNetwork(const CService& service)
+{
+    // The address's own network: a local or private address is still ipv4 or ipv6.
+    if (service.IsIPv4()) return "ipv4";
+    if (service.IsIPv6()) return "ipv6";
+    if (service.IsTor()) return "onion";
+    if (service.IsI2P()) return "i2p";
+    if (service.IsCJDNS()) return "cjdns";
+    // Internal addresses are never connected to.
+    return GetNetworkName(service.GetNetwork());
+}
+
+static UniValue PQEndpointToUniv(const PQEndpointKey& endpoint)
+{
+    UniValue obj(UniValue::VOBJ);
+    if (const CService* service{std::get_if<CService>(&endpoint)}) {
+        obj.pushKV("kind", "address");
+        obj.pushKV("network", PQEndpointNetwork(*service));
+        obj.pushKV("address", service->ToStringAddr());
+        obj.pushKV("port", service->GetPort());
+    } else {
+        const PQNameEndpoint& name{std::get<PQNameEndpoint>(endpoint)};
+        obj.pushKV("kind", "name_proxy");
+        obj.pushKV("network", "name_proxy");
+        obj.pushKV("address", name.hostname);
+        obj.pushKV("port", name.port);
+    }
+    return obj;
+}
+
+static UniValue PQCountsToUniv(const PQCounts& counts, bool inbound)
+{
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("switched", counts.switched);
+    obj.pushKV("legacy_peer", counts.legacy_peer);
+    obj.pushKV("malformed_record", counts.malformed_record);
+    obj.pushKV("first_packet_failed", counts.first_packet_failed);
+    obj.pushKV("abandoned", counts.abandoned);
+    obj.pushKV("internal_error", counts.internal_error);
+    if (inbound) {
+        obj.pushKV("shed", counts.shed);
+    } else {
+        obj.pushKV("closed_after_switch", counts.closed_after_switch);
+        obj.pushKV("fallback", counts.fallback);
+    }
+    return obj;
+}
+
+static UniValue PQRingToUniv(const PQFailureRing& ring)
+{
+    UniValue entries(UniValue::VARR);
+    for (const PQFailureEntry& entry : ring.entries) {
+        UniValue obj(UniValue::VOBJ);
+        obj.pushKV("sequence", entry.sequence);
+        obj.pushKV("time", TicksSinceEpoch<std::chrono::seconds>(entry.time));
+        obj.pushKV("endpoint", PQEndpointToUniv(entry.endpoint));
+        obj.pushKV("direction", entry.inbound ? "inbound" : "outbound");
+        obj.pushKV("connection_type", ConnectionTypeAsString(entry.connection_type));
+        obj.pushKV("peer_id", entry.peer_id);
+        obj.pushKV("outcome", std::string{PQOutcomeString(entry.outcome)});
+        obj.pushKV("reason", entry.reason);
+        entries.push_back(std::move(obj));
+    }
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("last_sequence", ring.last_sequence);
+    obj.pushKV("dropped", ring.dropped);
+    obj.pushKV("entries", std::move(entries));
+    return obj;
+}
+
+static RPCHelpMan getpqtransportinfo()
+{
+    const std::string causes{"malformed_record, first_packet_failed or closed_after_switch"};
+    const std::string windows{"3600, 14400 or 86400"};
+    return RPCHelpMan{
+        "getpqtransportinfo",
+        "Returns the state of the hybrid post-quantum key exchange (ML-KEM-1024 and ECDH) in v2 transport:\n"
+        "its configuration, the handshake outcomes since startup, load shedding, the fallback set, failure\n"
+        "streaks and the most recent failures. Every field is always present.\n"
+        "\n"
+        "-v2transport and -v2pqtransport are read once, at startup. A non-numeric -v2pqtransport value\n"
+        "(true reads as 0), or a double negative such as -nov2pqtransport=0 (read as 1), warns there and\n"
+        "states how it was read.\n"
+        "\n"
+        "Counters count events, not exclusive outcomes: switched counts key installations, even if the key\n"
+        "confirmation then fails; fallback counts entries into the fallback set, not plain v2 connections;\n"
+        "abandoned counts offers whose initiator sent no authenticated version packet before the connection\n"
+        "closed. Counters, rings and endpoint history are kept in memory only, and start over when\n"
+        "instance_id changes.\n"
+        "\n"
+        "A connection that closes on a hybrid failure reports transport_pq_status \"pending\" in getpeerinfo\n"
+        "until it is removed; its outcome is counted here.\n"
+        "\n"
+        "Reasons, by outcome:\n"
+        "legacy_peer: no_features, parse_error\n"
+        "malformed_record: ek_length, ek_modulus, ct_length\n"
+        "first_packet_failed: length, tag, not_decoy\n"
+        "closed_after_switch: eof, reset, timeout\n"
+        "abandoned: eof, reset, timeout, send_error, local, garbage_terminator, version_length, version_tag\n"
+        "fallback: malformed_record, first_packet_failed, closed_after_switch (the failure that completed the streak)\n"
+        "internal_error: keygen, check_public_key, encaps, decaps, cipher_state\n",
+        {},
+        RPCResult{
+            RPCResult::Type::OBJ, "", "",
+            {
+                {RPCResult::Type::BOOL, "enabled", "Whether new v2 connections negotiate hybrid keys: -v2transport and -v2pqtransport are both on"},
+                {RPCResult::Type::STR, "status", "enabled, disabled_v2pqtransport (-v2pqtransport=0) or disabled_v2transport (-v2transport=0, whatever -v2pqtransport is)"},
+                {RPCResult::Type::STR_HEX, "instance_id", "Random per process start"},
+                {RPCResult::Type::STR, "arith_backend", "The ML-KEM-1024 arithmetic code that runs: x86_64-avx2, aarch64-neon or portable"},
+                {RPCResult::Type::STR, "keccak_backend", "The Keccak code that runs: x86_64-avx2, aarch64 or portable"},
+                {RPCResult::Type::NUM_TIME, "since", "The " + UNIX_EPOCH_TIME + " of startup, from which the counters count"},
+                {RPCResult::Type::OBJ, "handshakes", "Hybrid negotiation events",
+                {
+                    {RPCResult::Type::OBJ, "inbound", "Of inbound connections", PQCountsDoc(/*inbound=*/true)},
+                    {RPCResult::Type::OBJ, "outbound", "Of outbound connections, manual ones included", PQCountsDoc(/*inbound=*/false)},
+                }},
+                {RPCResult::Type::OBJ, "load_shedding", "Inbound offer load shedding",
+                {
+                    {RPCResult::Type::BOOL, "active", "Whether responders stop offering, because more than threshold_per_s inbound offers were attempted in one second"},
+                    {RPCResult::Type::NUM, "threshold_per_s", "The threshold, in offers attempted per second"},
+                    {RPCResult::Type::NUM_TIME, "since", "The " + UNIX_EPOCH_TIME + " the current shedding period started, or 0 when inactive"},
+                }},
+                {RPCResult::Type::ARR, "fallback_set", "Endpoints that outbound connections reach with plain v2, after repeated hybrid failures",
+                {
+                    {RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::OBJ, "endpoint", "", PQEndpointDoc()},
+                        {RPCResult::Type::STR, "cause", "The failure that completed the streak: " + causes},
+                        {RPCResult::Type::STR, "reason", "Its reason"},
+                        {RPCResult::Type::NUM, "streak", "Consecutive counted failures"},
+                        {RPCResult::Type::NUM_TIME, "entered", "The " + UNIX_EPOCH_TIME + " the endpoint entered the set"},
+                        {RPCResult::Type::NUM_TIME, "expires", "The " + UNIX_EPOCH_TIME + " the window ends"},
+                        {RPCResult::Type::NUM, "window_seconds", "The window: " + windows},
+                    }},
+                }},
+                {RPCResult::Type::ARR, "failure_streaks", "Outbound endpoints with counted failures, not in the fallback set",
+                {
+                    {RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::OBJ, "endpoint", "", PQEndpointDoc()},
+                        {RPCResult::Type::STR, "cause", "The latest counted failure: " + causes},
+                        {RPCResult::Type::STR, "reason", "Its reason"},
+                        {RPCResult::Type::NUM, "streak", strprintf("Consecutive counted failures, below %u", PQ_FAILURE_THRESHOLD)},
+                        {RPCResult::Type::NUM_TIME, "last_failure", "The " + UNIX_EPOCH_TIME + " of the latest counted failure"},
+                        {RPCResult::Type::NUM, "next_window_seconds", "The window the endpoint enters at the threshold: " + windows},
+                    }},
+                }},
+                {RPCResult::Type::OBJ, "recent_failures", "The most recent non-success outcomes",
+                {
+                    PQRingDoc("inbound", "Of inbound connections"),
+                    PQRingDoc("outbound", "Of outbound connections, manual ones included"),
+                }},
+            }},
+        RPCExamples{
+            HelpExampleCli("getpqtransportinfo", "")
+            + HelpExampleRpc("getpqtransportinfo", "")
+        },
+        [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
+{
+    NodeContext& node = EnsureAnyNodeContext(request.context);
+    const CConnman& connman = EnsureConnman(node);
+    const PQTransportConfig& config{connman.GetPQTransportConfig()};
+    const PQTransportStats stats{connman.GetPQTransportStats()};
+    const mlkem::BackendNames backends{mlkem::GetBackendNames()};
+
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("enabled", config.Enabled());
+    obj.pushKV("status", !config.v2_enabled ? "disabled_v2transport" : !config.pq_requested ? "disabled_v2pqtransport" : "enabled");
+    obj.pushKV("instance_id", HexStr(stats.instance_id));
+    obj.pushKV("arith_backend", std::string{backends.arith});
+    obj.pushKV("keccak_backend", std::string{backends.keccak});
+    obj.pushKV("since", TicksSinceEpoch<std::chrono::seconds>(stats.since));
+
+    UniValue handshakes(UniValue::VOBJ);
+    handshakes.pushKV("inbound", PQCountsToUniv(stats.inbound, /*inbound=*/true));
+    handshakes.pushKV("outbound", PQCountsToUniv(stats.outbound, /*inbound=*/false));
+    obj.pushKV("handshakes", std::move(handshakes));
+
+    UniValue load_shedding(UniValue::VOBJ);
+    load_shedding.pushKV("active", stats.load_shedding.active);
+    load_shedding.pushKV("threshold_per_s", stats.load_shedding.threshold_per_s);
+    load_shedding.pushKV("since", TicksSinceEpoch<std::chrono::seconds>(stats.load_shedding.since));
+    obj.pushKV("load_shedding", std::move(load_shedding));
+
+    UniValue fallback_set(UniValue::VARR);
+    for (const PQFallbackStats& fallback : stats.fallback_set) {
+        UniValue entry(UniValue::VOBJ);
+        entry.pushKV("endpoint", PQEndpointToUniv(fallback.endpoint));
+        entry.pushKV("cause", std::string{PQOutcomeString(fallback.cause)});
+        entry.pushKV("reason", fallback.reason);
+        entry.pushKV("streak", uint64_t{fallback.streak});
+        entry.pushKV("entered", TicksSinceEpoch<std::chrono::seconds>(fallback.entered));
+        entry.pushKV("expires", TicksSinceEpoch<std::chrono::seconds>(fallback.expires));
+        entry.pushKV("window_seconds", Ticks<std::chrono::seconds>(fallback.expires - fallback.entered));
+        fallback_set.push_back(std::move(entry));
+    }
+    obj.pushKV("fallback_set", std::move(fallback_set));
+
+    UniValue failure_streaks(UniValue::VARR);
+    for (const PQStreakStats& streak : stats.failure_streaks) {
+        UniValue entry(UniValue::VOBJ);
+        entry.pushKV("endpoint", PQEndpointToUniv(streak.endpoint));
+        entry.pushKV("cause", std::string{PQOutcomeString(streak.cause)});
+        entry.pushKV("reason", streak.reason);
+        entry.pushKV("streak", uint64_t{streak.streak});
+        entry.pushKV("last_failure", TicksSinceEpoch<std::chrono::seconds>(streak.last_failure));
+        entry.pushKV("next_window_seconds", Ticks<std::chrono::seconds>(streak.next_window));
+        failure_streaks.push_back(std::move(entry));
+    }
+    obj.pushKV("failure_streaks", std::move(failure_streaks));
+
+    UniValue recent_failures(UniValue::VOBJ);
+    recent_failures.pushKV("inbound", PQRingToUniv(stats.inbound_failures));
+    recent_failures.pushKV("outbound", PQRingToUniv(stats.outbound_failures));
+    obj.pushKV("recent_failures", std::move(recent_failures));
+    return obj;
+},
+    };
+}
+
 void RegisterNetRPCCommands(CRPCTable& t)
 {
     static const CRPCCommand commands[]{
@@ -1357,6 +1672,7 @@ void RegisterNetRPCCommands(CRPCTable& t)
         {"network", &setnetworkactive},
         {"network", &getnodeaddresses},
         {"network", &getaddrmaninfo},
+        {"network", &getpqtransportinfo},
         {"hidden", &addconnection},
         {"hidden", &addpeeraddress},
         {"hidden", &sendmsgtopeer},
diff --git a/src/test/fuzz/rpc.cpp b/src/test/fuzz/rpc.cpp
index ce3ae1a10c..4ca52fdaae 100644
--- a/src/test/fuzz/rpc.cpp
+++ b/src/test/fuzz/rpc.cpp
@@ -182,6 +182,7 @@ const std::vector<std::string> RPC_COMMANDS_SAFE_FOR_FUZZING{
     "getorphanmetrics",
     "getorphantxs",
     "getpeerinfo",
+    "getpqtransportinfo",
     "getprioritisedtransactions",
     "getrawaddrman",
     "getrawmempool",
diff --git a/src/test/net_pq_tests.cpp b/src/test/net_pq_tests.cpp
index b63e6aeae9..b7df2d0fe9 100644
--- a/src/test/net_pq_tests.cpp
+++ b/src/test/net_pq_tests.cpp
@@ -9,15 +9,20 @@
 #include <key.h>
 #include <logging.h>
 #include <net.h>
+#include <net_processing.h>
 #include <netaddress.h>
 #include <netbase.h>
+#include <node/context.h>
 #include <random.h>
+#include <rpc/request.h>
+#include <rpc/server.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 <univalue.h>
 #include <util/sock.h>
 #include <util/time.h>
 
@@ -33,6 +38,7 @@
 #include <map>
 #include <memory>
 #include <optional>
+#include <set>
 #include <span>
 #include <string>
 #include <string_view>
@@ -269,7 +275,6 @@ struct PQNetSetup : public RegTestingSetup {
         static_assert(PQ_FAILURE_THRESHOLD == 3);
         InitConnman();
         m_connman.SetPeerConnectTimeout(60s);
-        m_connman.SetPQMode(PQMode::NEGOTIATE);
         SetMockTime(GetTime<std::chrono::seconds>());
         MockableSteadyClock::SetMockTime(STEADY_START);
     }
@@ -284,13 +289,16 @@ struct PQNetSetup : public RegTestingSetup {
     //! Where the mocked steady clock, which drives load shedding, starts.
     static constexpr std::chrono::seconds STEADY_START{3600};
 
-    /** Init() with room for inbound peers, v2 accepted, and the given load shedding threshold. */
-    void InitConnman(uint64_t shed_threshold = DEFAULT_PQ_SHED_THRESHOLD_PER_S)
+    /** Init() with room for inbound peers, v2 accepted, the given load shedding threshold, and
+     *  the given hybrid transport configuration: on by default. */
+    void InitConnman(uint64_t shed_threshold = DEFAULT_PQ_SHED_THRESHOLD_PER_S,
+                     PQTransportConfig pq = {.v2_enabled = true, .pq_requested = true})
     {
         CConnman::Options options;
         options.m_max_automatic_connections = DEFAULT_MAX_PEER_CONNECTIONS;
         options.m_local_services = NODE_P2P_V2;
         options.pq_shed_threshold_per_s = shed_threshold;
+        options.m_pq = pq;
         m_connman.Init(options);
         m_connman.SetMsgProc(&m_events);
     }
@@ -408,6 +416,34 @@ struct PQNetSetup : public RegTestingSetup {
 
     PQTransportStats Stats() const { return m_connman.GetPQTransportStats(); }
 
+    /** An RPC's result, with context as the node. */
+    static UniValue CallRPC(node::NodeContext& context, const std::string& method)
+    {
+        JSONRPCRequest request;
+        request.context = &context;
+        request.strMethod = method;
+        request.params = UniValue{UniValue::VARR};
+        if (RPCIsInWarmup(nullptr)) SetRPCWarmupFinished();
+        return tableRPC.execute(request);
+    }
+
+    /** getpqtransportinfo, with this fixture's connection manager as the node's. */
+    UniValue PQTransportInfo()
+    {
+        node::NodeContext context;
+        // Borrowed for the call, and released before the context is destroyed.
+        context.connman.reset(&m_connman);
+        std::optional<UniValue> result;
+        try {
+            result = CallRPC(context, "getpqtransportinfo");
+        } catch (...) {
+            (void)context.connman.release();
+            throw;
+        }
+        (void)context.connman.release();
+        return *result;
+    }
+
     /** How a test connection ends. */
     enum class End { MALFORMED, CONFIRMATION, PEER_EOF, PEER_RESET, TIMEOUT, LOCAL, SEND_ERROR, LEGACY, SUCCESS };
 
@@ -1509,13 +1545,15 @@ BOOST_AUTO_TEST_CASE(pq_history_eviction_all_in_fallback)
 }
 
 namespace {
-/** The warning names the backends that ran, and no remedy: no option forces portable code yet. */
+/** The warning names the backends that ran, and -mlkemportable as the remedy while native code runs. */
 std::string LocalFaultLine()
 {
     const auto backends{mlkem::GetBackendNames()};
+    const bool native{backends.arith != "portable" || backends.keccak != "portable"};
     return strprintf("v2 pq: local_fault arith=%s keccak=%s: hybrid handshakes failed with 8 distinct endpoints and none succeeded "
-                     "since startup, so this node's own ML-KEM code may be at fault.",
-                     backends.arith, backends.keccak);
+                     "since startup, so this node's own ML-KEM code may be at fault.%s",
+                     backends.arith, backends.keccak,
+                     native ? " Restart with -mlkemportable to use the portable implementation." : "");
 }
 } // namespace
 
@@ -1549,6 +1587,8 @@ BOOST_AUTO_TEST_CASE(pq_local_fault_warning_portable)
     BOOST_CHECK_EQUAL(mlkem::GetBackendNames().arith, "portable");
     const std::string text{LocalFaultLine()};
     BOOST_CHECK(text.find("arith=portable keccak=portable:") != std::string::npos);
+    // Portable code already runs: no remedy to name.
+    BOOST_CHECK(text.find("-mlkemportable") == std::string::npos);
     LogLineCounter warnings{"v2 pq: local_fault"};
     {
         DebugLogHelper expect{text, AtLevel({text}, LineLevel::WARNING)};
@@ -1724,8 +1764,7 @@ BOOST_AUTO_TEST_CASE(pq_load_shedding)
 BOOST_AUTO_TEST_CASE(pq_load_shedding_off)
 {
     // With the switch off, inbound transports never ask the gate: nothing is counted or shed.
-    InitConnman(/*shed_threshold=*/1);
-    m_connman.SetPQMode(PQMode::OFF);
+    InitConnman(/*shed_threshold=*/1, {.v2_enabled = true, .pq_requested = false});
     for (int i{0}; i < 5; ++i) {
         Link link{Accept()};
         Receive(link, InitiatorKey());
@@ -1824,4 +1863,199 @@ BOOST_AUTO_TEST_CASE(pq_load_shedding_socket_thread)
     BOOST_CHECK_EQUAL(stopped.m_count, 1);
 }
 
+BOOST_AUTO_TEST_CASE(pq_config)
+{
+    // Init() takes the negotiation of new connections, inbound and outbound, from the
+    // configuration: on only with both switches on.
+    const auto create_sock_orig{CreateSock};
+    CreateSock = [](int, int, int) -> std::unique_ptr<Sock> { return std::make_unique<ZeroSock>(); };
+    for (const auto& [config, enabled] : std::vector<std::pair<PQTransportConfig, bool>>{
+             {{.v2_enabled = false, .pq_requested = true}, false},
+             {{.v2_enabled = true, .pq_requested = false}, false},
+             {{.v2_enabled = true, .pq_requested = true}, true},
+         }) {
+        BOOST_CHECK_EQUAL(config.Enabled(), enabled);
+        InitConnman(DEFAULT_PQ_SHED_THRESHOLD_PER_S, config);
+        Link inbound{Accept()};
+        V2Transport peer{Initiator()};
+        Exchange(inbound, peer);
+        const Transport::Info info{inbound.node->m_transport->GetInfo()};
+        BOOST_CHECK_EQUAL(info.transport_pq, enabled);
+        BOOST_CHECK(info.transport_pq_status == (enabled ? PQStatus::HYBRID : PQStatus::OFF));
+        const std::unique_ptr<CNode> outbound{m_connman.ConnectNodeOnly("5.6.7.8:18555", ConnectionType::MANUAL, /*use_v2transport=*/true)};
+        BOOST_REQUIRE(outbound);
+        BOOST_CHECK(outbound->m_transport->GetInfo().transport_pq_status == (enabled ? PQStatus::PENDING : PQStatus::OFF));
+    }
+
+    // -test=pq_fail_first_packet corrupts this side's shared secret, so its check of the peer's key
+    // confirmation fails (and it closes before its own confirmation is sent).
+    InitConnman(DEFAULT_PQ_SHED_THRESHOLD_PER_S, {.v2_enabled = true, .pq_requested = true, .fail_first_packet = true});
+    Link inbound{Accept()};
+    V2Transport peer{Initiator()};
+    Exchange(inbound, peer);
+    const PQHandshake::Snapshot ours{inbound.node->m_transport->GetPQSnapshot()};
+    BOOST_CHECK(ours.switched);
+    BOOST_CHECK(!ours.confirmed);
+    BOOST_CHECK(ours.failure == PQFailure::CONFIRM_LENGTH || ours.failure == PQFailure::CONFIRM_TAG);
+    BOOST_CHECK(inbound.node->fDisconnect);
+    BOOST_CHECK(peer.GetPQSnapshot().switched);
+    CreateSock = create_sock_orig;
+}
+
+BOOST_AUTO_TEST_CASE(pq_rpc_status)
+{
+    // status names the first switch that is off: v2 before the hybrid key exchange.
+    for (const auto& [config, status] : std::vector<std::pair<PQTransportConfig, std::string>>{
+             {{.v2_enabled = false, .pq_requested = false}, "disabled_v2transport"},
+             {{.v2_enabled = false, .pq_requested = true}, "disabled_v2transport"},
+             {{.v2_enabled = true, .pq_requested = false}, "disabled_v2pqtransport"},
+             {{.v2_enabled = true, .pq_requested = true}, "enabled"},
+         }) {
+        InitConnman(DEFAULT_PQ_SHED_THRESHOLD_PER_S, config);
+        const UniValue info{PQTransportInfo()};
+        BOOST_CHECK_EQUAL(info["status"].get_str(), status);
+        BOOST_CHECK_EQUAL(info["enabled"].get_bool(), config.Enabled());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(pq_rpc_load_shedding)
+{
+    // The second offer within one second, above a threshold of 1, is shed: load_shedding is active
+    // since now, and the inbound shed counter counts it.
+    InitConnman(/*shed_threshold=*/1);
+    for (int i{0}; i < 2; ++i) {
+        Link link{Accept()};
+        Receive(link, InitiatorKey());
+        Pass(link);
+    }
+    const UniValue info{PQTransportInfo()};
+    BOOST_CHECK_EQUAL(info["load_shedding"].write(),
+                      strprintf(R"({"active":true,"threshold_per_s":1,"since":%d})", TicksSinceEpoch<std::chrono::seconds>(Now<NodeSeconds>())));
+    BOOST_CHECK_EQUAL(info["handshakes"]["inbound"]["shed"].getInt<uint64_t>(), 1U);
+}
+
+BOOST_AUTO_TEST_CASE(pq_rpc_endpoints)
+{
+    // Each kind of endpoint, as the outbound ring and the failure streaks render it: an address's
+    // own network, whether or not it is publicly routable, its canonical text without the port.
+    CNetAddr onion, i2p;
+    BOOST_REQUIRE(onion.SetSpecial("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion"));
+    BOOST_REQUIRE(i2p.SetSpecial("udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p"));
+    const std::vector<std::pair<PQEndpointKey, std::string>> endpoints{
+        {LookupNumeric("10.1.2.3", 8333), R"({"kind":"address","network":"ipv4","address":"10.1.2.3","port":8333})"},
+        {LookupNumeric("::ffff:1.2.3.4", 8334), R"({"kind":"address","network":"ipv4","address":"1.2.3.4","port":8334})"},
+        {LookupNumeric("2001:db8::1", 18444), R"({"kind":"address","network":"ipv6","address":"2001:db8::1","port":18444})"},
+        {LookupNumeric("::1", 18445), R"({"kind":"address","network":"ipv6","address":"::1","port":18445})"},
+        {CService{onion, 8333}, R"({"kind":"address","network":"onion","address":"pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion","port":8333})"},
+        {CService{i2p, 0}, R"({"kind":"address","network":"i2p","address":"udhdrtrcetjm5sxzskjyr5ztpeszydbh4dpl3pl4utgqqw2v4jna.b32.i2p","port":0})"},
+        {MakePQNameEndpoint("PQTest.Example.", 8333), R"({"kind":"name_proxy","network":"name_proxy","address":"pqtest.example","port":8333})"},
+    };
+    for (const auto& [endpoint, _] : endpoints) Connect(endpoint, End::MALFORMED);
+    const UniValue info{PQTransportInfo()};
+    const UniValue& entries{info["recent_failures"]["outbound"]["entries"]};
+    const UniValue& streaks{info["failure_streaks"]};
+    BOOST_REQUIRE_EQUAL(entries.size(), endpoints.size());
+    BOOST_REQUIRE_EQUAL(streaks.size(), endpoints.size());
+    std::set<std::string> streak_endpoints;
+    for (size_t i{0}; i < endpoints.size(); ++i) {
+        BOOST_CHECK_EQUAL(entries[i]["endpoint"].write(), endpoints[i].second);
+        streak_endpoints.insert(streaks[i]["endpoint"].write());
+    }
+    for (const auto& [_, rendered] : endpoints) BOOST_CHECK(streak_endpoints.contains(rendered));
+}
+
+BOOST_AUTO_TEST_CASE(pq_rpc_windows)
+{
+    // An endpoint's windows escalate, 1 h, 4 h, then 24 h: window_seconds and next_window_seconds
+    // show the escalated values.
+    const PQEndpointKey endpoint{TestEndpoint(9, 0)};
+    const auto window{[&](const std::string& field) {
+        const UniValue info{PQTransportInfo()};
+        BOOST_REQUIRE_EQUAL(info["fallback_set"].size(), 1U);
+        BOOST_REQUIRE(info["failure_streaks"].empty());
+        const UniValue& entry{info["fallback_set"][0]};
+        BOOST_CHECK_EQUAL(entry["expires"].getInt<int64_t>() - entry["entered"].getInt<int64_t>(), entry[field].getInt<int64_t>());
+        return entry[field].getInt<int64_t>();
+    }};
+    const auto next_window{[&] {
+        const UniValue info{PQTransportInfo()};
+        BOOST_REQUIRE(info["fallback_set"].empty());
+        BOOST_REQUIRE_EQUAL(info["failure_streaks"].size(), 1U);
+        return info["failure_streaks"][0]["next_window_seconds"].getInt<int64_t>();
+    }};
+    const auto expire{[&](std::chrono::seconds window) {
+        SetMockTime(GetTime<std::chrono::seconds>() + window + 1s);
+        // An expired window isn't listed, and the streak starts again with the next failure.
+        const UniValue info{PQTransportInfo()};
+        BOOST_CHECK(info["fallback_set"].empty());
+        BOOST_CHECK(info["failure_streaks"].empty());
+    }};
+
+    Connect(endpoint, End::MALFORMED);
+    BOOST_CHECK_EQUAL(next_window(), 3600);
+    Connect(endpoint, End::MALFORMED);
+    Connect(endpoint, End::MALFORMED);
+    BOOST_CHECK_EQUAL(window("window_seconds"), 3600);
+    expire(3600s);
+    Connect(endpoint, End::MALFORMED);
+    BOOST_CHECK_EQUAL(next_window(), 14400);
+    Connect(endpoint, End::MALFORMED);
+    Connect(endpoint, End::MALFORMED);
+    BOOST_CHECK_EQUAL(window("window_seconds"), 14400);
+    expire(14400s);
+    Connect(endpoint, End::MALFORMED);
+    BOOST_CHECK_EQUAL(next_window(), 86400);
+    Connect(endpoint, End::MALFORMED);
+    Connect(endpoint, End::MALFORMED);
+    BOOST_CHECK_EQUAL(window("window_seconds"), 86400);
+    expire(86400s);
+    Connect(endpoint, End::MALFORMED);
+    BOOST_CHECK_EQUAL(next_window(), 86400);
+}
+
+BOOST_AUTO_TEST_CASE(pq_rpc_listed_peers)
+{
+    // getnetworkinfo's connections_pq counts exactly the peers getpeerinfo lists: a hybrid
+    // connection the peer manager doesn't know yet is in the connection count, but not listed or
+    // counted as hybrid.
+    auto& connman{static_cast<ConnmanTestMsg&>(*m_node.connman)};
+    CNode* node{new CNode{/*id=*/100000, std::make_shared<ZeroSock>(), CAddress{LookupNumeric("10.8.0.1", 50000), NODE_NONE},
+                          /*nKeyedNetGroupIn=*/0, /*nLocalHostNonceIn=*/0, CAddress{}, /*addrNameIn=*/"", ConnectionType::INBOUND,
+                          /*inbound_onion=*/false, CNodeOptions{.use_v2transport = true, .pq = {.mode = PQMode::NEGOTIATE}}}};
+    V2Transport peer{Initiator()};
+    const auto deliver{[](Transport& from, Transport& to) {
+        const std::vector<uint8_t> bytes{PeerBytes(from)};
+        std::span<const uint8_t> remaining{bytes};
+        while (!remaining.empty()) {
+            BOOST_REQUIRE(to.ReceivedBytes(remaining));
+            if (to.ReceivedMessageComplete()) {
+                bool reject{false};
+                to.GetReceivedMessage({}, reject);
+            }
+        }
+    }};
+    for (int round{0}; round < 4; ++round) {
+        deliver(peer, *node->m_transport);
+        deliver(*node->m_transport, peer);
+    }
+    BOOST_REQUIRE(node->m_transport->GetInfo().transport_pq);
+    connman.AddTestNode(*node);
+
+    UniValue networkinfo{CallRPC(m_node, "getnetworkinfo")};
+    BOOST_CHECK_EQUAL(networkinfo["connections"].getInt<int>(), 1);
+    BOOST_CHECK_EQUAL(networkinfo["connections_pq"].getInt<int>(), 0);
+    BOOST_CHECK(CallRPC(m_node, "getpeerinfo").empty());
+
+    m_node.peerman->InitializeNode(*node, NODE_NONE);
+    networkinfo = CallRPC(m_node, "getnetworkinfo");
+    BOOST_CHECK_EQUAL(networkinfo["connections_pq"].getInt<int>(), 1);
+    const UniValue peers{CallRPC(m_node, "getpeerinfo")};
+    BOOST_REQUIRE_EQUAL(peers.size(), 1U);
+    BOOST_CHECK(peers[0]["transport_pq"].get_bool());
+    BOOST_CHECK_EQUAL(peers[0]["transport_pq_status"].get_str(), "hybrid");
+
+    m_node.peerman->FinalizeNode(*node);
+    connman.ClearTestNodes();
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/util/net.h b/src/test/util/net.h
index 7081638a9b..ecf6e87b52 100644
--- a/src/test/util/net.h
+++ b/src/test/util/net.h
@@ -106,8 +106,6 @@ struct ConnmanTestMsg : public CConnman {
         DisconnectNodes();
     }
 
-    void SetPQMode(PQMode mode) { m_pq_mode = mode; }
-
     /** How many distinct failing endpoints the local-fault warning has counted. */
     size_t PQLocalFaultEndpoints() const EXCLUSIVE_LOCKS_REQUIRED(!m_pq_mutex)
     {
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index e207534600..e794655af0 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -27,6 +27,7 @@ function(create_test_config)
   set_configure_variable(ENABLE_EXTERNAL_SIGNER ENABLE_EXTERNAL_SIGNER)
   set_configure_variable(WITH_USDT ENABLE_USDT_TRACEPOINTS)
   set_configure_variable(ENABLE_IPC ENABLE_IPC)
+  set_configure_variable(ENABLE_MLKEM_NATIVE ENABLE_MLKEM_NATIVE)
 
   configure_file(config.ini.in config.ini USE_SOURCE_PERMISSIONS @ONLY)
 endfunction()
diff --git a/test/config.ini.in b/test/config.ini.in
index f695dec47f..b7b70e6296 100644
--- a/test/config.ini.in
+++ b/test/config.ini.in
@@ -27,3 +27,4 @@ RPCAUTH=@abs_top_srcdir@/share/rpcauth/rpcauth.py
 @ENABLE_EXTERNAL_SIGNER_TRUE@ENABLE_EXTERNAL_SIGNER=true
 @ENABLE_USDT_TRACEPOINTS_TRUE@ENABLE_USDT_TRACEPOINTS=true
 @ENABLE_IPC_TRUE@ENABLE_IPC=true
+@ENABLE_MLKEM_NATIVE_TRUE@ENABLE_MLKEM_NATIVE=true
diff --git a/test/functional/interface_bitcoin_cli.py b/test/functional/interface_bitcoin_cli.py
index d01382123c..befd799208 100755
--- a/test/functional/interface_bitcoin_cli.py
+++ b/test/functional/interface_bitcoin_cli.py
@@ -5,12 +5,14 @@
 """Test qbit-cli"""
 
 from decimal import Decimal
+import itertools
 import re
 import socket
 import time
 
 from test_framework.blocktools import COINBASE_MATURITY
 from test_framework.netutil import test_ipv6_local
+from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
@@ -90,12 +92,17 @@ def can_connect_to_ipv6_rpc(port):
 class TestBitcoinCli(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
-        self.num_nodes = 1
+        # Node 1 is the hybrid post-quantum peer of test_netinfo_pq.
+        self.num_nodes = 2
         self.uses_wallet = None
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_cli()
 
+    def setup_network(self):
+        # Node 1 is only test_netinfo_pq's peer: nothing connects or syncs to it before.
+        self.setup_nodes()
+
     def test_netinfo(self):
         """Test -netinfo output format."""
         self.log.info("Test -netinfo header and separate local services line")
@@ -109,9 +116,33 @@ def test_netinfo(self):
         assert re.match(rf"^{re.escape(self.config['environment']['CLIENT_NAME'])} client.+services nwl(?:2)?a$", det[0])
         assert not any(line.startswith("Local services:") for line in det)
 
+    def test_netinfo_pq(self):
+        """Test -netinfo marks hybrid post-quantum peers 2p, and explains it."""
+        self.log.info("Test -netinfo shows 2p for a hybrid post-quantum peer and 2 for a legacy v2 peer")
+        pq_args = ["-v2transport=1", "-v2pqtransport=1"]
+        self.restart_node(0, extra_args=pq_args)
+        self.restart_node(1, extra_args=pq_args)
+        self.connect_nodes(0, 1)
+        # A Python v2 peer, which answers without an offer: a legacy peer.
+        self.nodes[0].add_outbound_p2p_connection(P2PInterface(), p2p_idx=0, supports_v2_p2p=True, advertise_v2_p2p=True)
+        assert_equal(sorted(peer["transport_pq_status"] for peer in self.nodes[0].getpeerinfo()), ["hybrid", "legacy_peer"])
+        out = self.nodes[0].cli('-netinfo', '1').send_cli().splitlines()
+        header = next(i for i, line in enumerate(out) if line.startswith("<->"))
+        rows = list(itertools.takewhile(lambda line: line.startswith(("out ", " in ")), out[header + 1:]))
+        # The two-character v column ends at the header's "v".
+        v_end = out[header].index("  v  ") + 3
+        assert_equal(sorted(row[v_end - 2:v_end] for row in rows), [" 2", "2p"])
+
+        self.log.info("Test the -netinfo legend explains 2p")
+        legend = self.nodes[0].cli('-netinfo', 'help').send_cli()
+        assert '"2p" - v2 with hybrid post-quantum session keys (getpeerinfo "transport_pq" is true)' in legend
+
+        self.nodes[0].disconnect_p2ps()
+        self.stop_node(1)
+
     def run_test(self):
         """Main test logic"""
-        self.generate(self.nodes[0], BLOCKS)
+        self.generate(self.nodes[0], BLOCKS, sync_fun=self.no_op)
         block_subsidy = self.nodes[0].getblock(self.nodes[0].getblockhash(1), 2)["tx"][0]["vout"][0]["value"]
         initial_balance = (BLOCKS - COINBASE_MATURITY) * block_subsidy
 
@@ -274,7 +305,7 @@ def run_test(self):
             w1.sendtoaddress(w3.getnewaddress(), send_amount_2)
 
             # Mine a block to confirm.
-            self.generate(self.nodes[0], 1)
+            self.generate(self.nodes[0], 1, sync_fun=self.no_op)
             amounts = [w1.getbalance(), w2.getbalance(), w3.getbalance()]
 
             self.log.info("Test -getinfo with multiple wallets and -rpcwallet returns specified wallet balance")
@@ -416,9 +447,10 @@ def run_test(self):
             assert_raises_rpc_error(-19, WALLET_NOT_SPECIFIED, self.nodes[0].cli('-generate', 1, 2, 3).echo)
         else:
             self.log.info("*** Wallet not compiled; cli getwalletinfo and -getinfo wallet tests skipped")
-            self.generate(self.nodes[0], 25)  # maintain block parity with the wallet_compiled conditional branch
+            self.generate(self.nodes[0], 25, sync_fun=self.no_op)  # maintain block parity with the wallet_compiled conditional branch
 
         self.test_netinfo()
+        self.test_netinfo_pq()
 
         self.log.info("Test -version with node stopped")
         self.stop_node(0)
diff --git a/test/functional/p2p_v2_previous_release.py b/test/functional/p2p_v2_previous_release.py
index bf4b133edd..b657696264 100755
--- a/test/functional/p2p_v2_previous_release.py
+++ b/test/functional/p2p_v2_previous_release.py
@@ -21,12 +21,15 @@
 - test_limits: v1.0.0 disconnects at once when a packet's length exceeds
   MAX_CONTENTS_LEN (4,000,013 bytes), not at that length, and disconnects a
   stalled handshake at -peertimeout.
+- test_netinfo: this release's qbit-cli -netinfo against v1.0.0, whose getpeerinfo
+  has no transport_pq, shows a v2 peer as 2, without errors.
 
 The peer is a BIP324 implementation on a plain socket, so the test decides
 every byte it sends and when.
 """
 from concurrent.futures import ThreadPoolExecutor
 from io import BytesIO
+import itertools
 import os
 import shutil
 import socket
@@ -46,7 +49,7 @@
     P2P_VERSION_RELAY,
 )
 from test_framework.test_framework import BitcoinTestFramework, SkipTest
-from test_framework.test_node import release_info
+from test_framework.test_node import TestNodeCLI, release_info
 from test_framework.util import (
     MAX_NODES,
     assert_equal,
@@ -263,6 +266,8 @@ def run_test(self):
 
         self.test_version_contents()
         self.test_limits()
+        if self.is_cli_compiled():
+            self.test_netinfo()
 
     def open_peers(self, roles):
         """Open one raw v2 connection per role: "responder" means v1.0.0 responds (we
@@ -343,6 +348,21 @@ def test_version_contents(self):
         self.log.info(f"... and after a {VERSION_DELAY} s pause before the version packet")
         self.check_cases(delay=VERSION_DELAY)
 
+    def test_netinfo(self):
+        self.log.info("This release's qbit-cli -netinfo against v1.0.0 shows a v2 peer as 2")
+        peer, = self.open_peers(["responder"])
+        self.run_handshake(peer, "responder", b"", delay=0)
+        assert "transport_pq" not in self.peer_info(peer, "responder")
+        cli = TestNodeCLI(self.get_binaries(), self.node.datadir_path)
+        out = cli("-netinfo", "1").send_cli().splitlines()
+        header = next(i for i, line in enumerate(out) if line.startswith("<->"))
+        rows = list(itertools.takewhile(lambda line: line.startswith(("out ", " in ")), out[header + 1:]))
+        # The two-character v column ends at the header's "v".
+        v_end = out[header].index("  v  ") + 3
+        assert_equal([row[v_end - 2:v_end] for row in rows], [" 2"])
+        peer.close()
+        self.wait_until(lambda: not self.node.getpeerinfo())
+
     def test_limits(self):
         for role in ("responder", "initiator"):
             self.log.info(f"v1.0.0 as {role} waits for a packet of exactly MAX_CONTENTS_LEN bytes")
diff --git a/test/functional/rpc_net.py b/test/functional/rpc_net.py
index 462e47df74..0bac288e97 100755
--- a/test/functional/rpc_net.py
+++ b/test/functional/rpc_net.py
@@ -178,6 +178,9 @@ def test_getpeerinfo(self):
                 "synced_headers": -1,
                 "timeoffset": 0,
                 "transport_protocol_type": "v1" if not self.options.v2transport else "v2",
+                # A Python peer has no hybrid post-quantum transport, and this node's switch is off.
+                "transport_pq": False,
+                "transport_pq_status": "v1" if not self.options.v2transport else "off",
                 "version": 0,
             },
         )
@@ -212,6 +215,8 @@ def test_getnetworkinfo(self):
         assert_equal(info['connections'], 2)
         assert_equal(info['connections_in'], 1)
         assert_equal(info['connections_out'], 1)
+        # The hybrid post-quantum switch is off.
+        assert_equal(info['connections_pq'], 0)
 
         with self.nodes[0].assert_debug_log(expected_msgs=['SetNetworkActive: false\n']):
             self.nodes[0].setnetworkactive(state=False)
diff --git a/test/functional/rpc_pqtransport.py b/test/functional/rpc_pqtransport.py
new file mode 100755
index 0000000000..de45999159
--- /dev/null
+++ b/test/functional/rpc_pqtransport.py
@@ -0,0 +1,708 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 The qbit developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test the hybrid post-quantum v2 transport's operator surface (#184 part 6).
+
+Options and startup line:
+- test_configuration: -v2pqtransport on the command line, in qbit.conf, negated and
+  across restarts, observed on a live connection between two nodes; the warnings for a
+  contradictory or non-numeric setting, or a double negative; -help; the three startup lines.
+- test_portable_options: -mlkemportable and -test=mlkem_portable make the startup line
+  report portable code, and a non-numeric -mlkemportable or a double negative warns; the
+  test options are regtest only and print nothing to stderr.
+
+RPC (getpqtransportinfo, and the getpeerinfo and getnetworkinfo fields):
+- test_states: every getpqtransportinfo field with the switch off, with v2 off, on, and
+  with an endpoint in the fallback set; instance_id changes on restart; each
+  transport_pq_status.
+- test_counts: exact per-direction counts of hybrid, legacy and failing connections.
+  -test=pq_fail_first_packet on one node makes hybrid handshakes fail in both directions.
+- test_abandoned: an initiator that reads the offer and closes, or stalls until the
+  handshake times out, counts one abandoned offer and no switch.
+- test_rings: 300 inbound failures keep the newest 256, with contiguous sequences, and
+  don't evict the outbound ring's entry.
+- test_endpoints: a name-proxy destination (through a SOCKS5 proxy) and, with local IPv6, an
+  IPv6 address, as getpqtransportinfo renders their endpoints.
+- test_connection_count: connections_pq counts the peers getpeerinfo shows with
+  transport_pq, and is 0 with the switch off.
+"""
+from concurrent.futures import ThreadPoolExecutor
+import os
+import platform
+import re
+import socket
+import subprocess
+import sys
+import time
+
+from test_framework.netutil import test_ipv6_local
+from test_framework.socks5 import (
+    Socks5Configuration,
+    Socks5Server,
+)
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    append_config,
+    assert_equal,
+    p2p_port,
+    write_config,
+)
+from test_framework.v2_p2p import (
+    CHACHA20POLY1305_EXPANSION,
+    HEADER_LEN,
+    LENGTH_FIELD_LEN,
+    EncryptedP2PState,
+)
+
+# The startup line: the state, then the active ML-KEM-1024 backends.
+STARTUP_LINE = re.compile(
+    r"v2 pq: (enabled|disabled \(-v2pqtransport=0\)|disabled \(-v2transport=0\)) "
+    r"arith=(x86_64-avx2|aarch64-neon|portable) keccak=(x86_64-avx2|aarch64|portable)\n")
+ENABLED = "enabled"
+DISABLED_PQ = "disabled (-v2pqtransport=0)"
+DISABLED_V2 = "disabled (-v2transport=0)"
+CONTRADICTION_WARNING = ("Warning: -v2pqtransport=1 has no effect because -v2transport=0. "
+                         "Set -v2transport=1 to use hybrid post-quantum v2 transport.")
+TEST_OPTION_ERROR = "Error: -test=<option> can only be used with regtest"
+
+# Node arguments: v2 without and with the hybrid key exchange, and with failing confirmations.
+NO_PQ = ["-v2transport=1"]
+PQ = ["-v2transport=1", "-v2pqtransport=1"]
+PQ_FAIL = PQ + ["-test=pq_fail_first_packet"]
+
+# The offer: one 0xF0 record, CompactSize(1,569) || 0xF0 || a 1,568-byte encapsulation key.
+OFFER_LEN = 1572
+OFFER_PREFIX = bytes.fromhex("fd2106f0")
+RING_SIZE = 256
+FIRST_WINDOW = 3600
+
+
+# The effect each warning states.
+PQ_ON = "hybrid transport is ON"
+PQ_OFF = "hybrid transport is OFF"
+PORTABLE = "ML-KEM-1024 uses portable code"
+NATIVE = "ML-KEM-1024 uses native code where the CPU supports it"
+
+
+def non_numeric_warning(value, read_as, effect, option="v2pqtransport"):
+    return (f"Warning: -{option}={value} is not a number and was read as -{option}={read_as}: {effect}. "
+            f"Use -{option}=1 or -{option}=0.")
+
+
+def double_negative_warning(effect, option="v2pqtransport"):
+    return (f"Warning: -no{option} was given 0 or a non-numeric value, so it was read as -{option}=1: {effect}. "
+            f"Use -{option}=0 to switch it off.")
+
+
+def expected_default_backends(config):
+    """The ML-KEM-1024 backends a node runs here by default, or None if this test can't tell."""
+    if not config["components"].getboolean("ENABLE_MLKEM_NATIVE", fallback=False):
+        return ("portable", "portable")
+    machine = platform.machine().lower()
+    if sys.platform == "linux" and machine in ("x86_64", "amd64"):
+        flags = set()
+        with open("/proc/cpuinfo", encoding="utf8") as cpuinfo:
+            for line in cpuinfo:
+                if line.startswith("flags"):
+                    flags = set(line.split(":", 1)[1].split())
+                    break
+        # What the x86_64 assembly needs (cpu_features::HasMlkemX86Native()); Linux lists AVX and
+        # AVX2 only when the OS saves YMM state.
+        native = {"avx", "avx2", "ssse3", "sse4_1", "popcnt", "bmi2"} <= flags
+        return ("x86_64-avx2", "x86_64-avx2") if native else ("portable", "portable")
+    if sys.platform == "darwin" and machine == "arm64":
+        return ("aarch64-neon", "aarch64")
+    return None
+
+
+def zero_counts():
+    """getpqtransportinfo's handshakes with nothing counted."""
+    common = {"switched": 0, "legacy_peer": 0, "malformed_record": 0, "first_packet_failed": 0, "abandoned": 0, "internal_error": 0}
+    return {
+        "inbound": {**common, "shed": 0},
+        "outbound": {**common, "closed_after_switch": 0, "fallback": 0},
+    }
+
+
+def empty_ring():
+    return {"last_sequence": 0, "dropped": 0, "entries": []}
+
+
+def local_endpoint(port):
+    return {"kind": "address", "network": "ipv4", "address": "127.0.0.1", "port": port}
+
+
+class OfferReader:
+    """An initiator on a plain socket: it sends its key, reads the node's key, garbage and
+    version packet, and never sends its own version packet."""
+
+    def __init__(self, port):
+        self.sock = socket.create_connection(("127.0.0.1", port), timeout=60)
+        self.local_port = self.sock.getsockname()[1]
+        self.state = EncryptedP2PState(initiating=True, net="regtest")
+        self.recvbuf = b""
+        self.sock.sendall(self.state.generate_keypair_and_garbage(garbage_len=0))
+
+    def _recv_more(self):
+        data = self.sock.recv(65536)
+        assert data, "the node closed the connection"
+        self.recvbuf += data
+
+    def _recv_exact(self, n):
+        while len(self.recvbuf) < n:
+            self._recv_more()
+        data, self.recvbuf = self.recvbuf[:n], self.recvbuf[n:]
+        return data
+
+    def read_version_contents(self):
+        """The contents of the node's version packet."""
+        st = self.state
+        ellswift_theirs = self._recv_exact(64)
+        st.initialize_v2_transport(st.v2_ecdh(st.privkey_ours, ellswift_theirs, st.ellswift_ours, True))
+        terminator = st.peer["recv_garbage_terminator"]
+        while terminator not in self.recvbuf:
+            self._recv_more()
+        garbage, self.recvbuf = self.recvbuf.split(terminator, 1)
+        length = int.from_bytes(st.peer["recv_L"].crypt(self._recv_exact(LENGTH_FIELD_LEN)), "little")
+        # The version packet authenticates the garbage.
+        plaintext = st.peer["recv_P"].decrypt(garbage, self._recv_exact(HEADER_LEN + length + CHACHA20POLY1305_EXPANSION))
+        assert plaintext is not None
+        return plaintext[HEADER_LEN:]
+
+    def close(self):
+        """End the stream, so the node reads eof, and read until it closes too: nothing left unread
+        turns the close into a reset."""
+        self.sock.shutdown(socket.SHUT_WR)
+        while self.sock.recv(65536):
+            pass
+        self.sock.close()
+
+
+def abandon_offer(port):
+    """An inbound v2 connection that sends a key and ends the stream: the node's offer is abandoned (eof)."""
+    with socket.create_connection(("127.0.0.1", port), timeout=60) as sock:
+        # Any 64 bytes are a valid ElligatorSwift key; a first byte unlike the network magic's is v2 at once.
+        sock.sendall(bytes(64))
+        sock.shutdown(socket.SHUT_WR)
+        while sock.recv(65536):
+            pass
+
+
+class PQTransportTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.setup_clean_chain = True
+        # Whatever the suite's transport flag, these nodes use v2.
+        self.extra_args = [NO_PQ] * self.num_nodes
+
+    def setup_network(self):
+        # Connections are made by the tests.
+        self.setup_nodes()
+
+    def startup_line(self, node):
+        """The state and backends of the node's latest startup line."""
+        lines = STARTUP_LINE.findall(node.debug_log_path.read_text(encoding="utf-8"))
+        assert lines, "no startup line"
+        return lines[-1]
+
+    def check_start(self, args, state, *, expected_stderr=""):
+        """Start node 0 with args, check its startup line's state and stderr, and stop it. Returns
+        the startup line."""
+        self.start_node(0, extra_args=args)
+        line = self.startup_line(self.nodes[0])
+        assert_equal(line[0], state)
+        self.stop_node(0, expected_stderr=expected_stderr)
+        return line
+
+    def check_connection(self, *, hybrid):
+        """Connect node 0 to node 1, check whether both switched to hybrid keys, and disconnect."""
+        initiator = ["v2 pq: switched role=initiator"]
+        responder = ["v2 pq: switched role=responder"]
+        with self.nodes[0].assert_debug_log(initiator if hybrid else [], unexpected_msgs=[] if hybrid else initiator):
+            with self.nodes[1].assert_debug_log(responder if hybrid else [], unexpected_msgs=[] if hybrid else responder):
+                self.connect_nodes(0, 1)
+        self.disconnect_nodes(0, 1)
+
+    def handshakes(self, node):
+        return node.getpqtransportinfo()["handshakes"]
+
+    def wait_for_handshakes(self, node, before, *alternatives):
+        """Wait until node's counts are before plus exactly one of the alternatives, each a dict
+        of direction to counter increments, and return the index of the one that matched."""
+        expected = []
+        for increments in alternatives:
+            counts = {direction: dict(values) for direction, values in before.items()}
+            for direction, deltas in increments.items():
+                for counter, delta in deltas.items():
+                    counts[direction][counter] += delta
+            expected.append(counts)
+        self.wait_until(lambda: self.handshakes(node) in expected)
+        return expected.index(self.handshakes(node))
+
+    def wait_for_no_peers(self, *nodes):
+        for node in nodes:
+            self.wait_until(lambda: node.getpeerinfo() == [])
+
+    def failing_connection(self, a, b, *, enters_fallback=False):
+        """Connect node a to node b, whose hybrid handshake fails its key confirmation
+        (-test=pq_fail_first_packet on either side), and wait until both removed the peer.
+
+        The initiator's version packet and confirmation travel together, so the responder's
+        check of that confirmation fails, and it closes before its own confirmation leaves: the
+        initiator then counts closed_after_switch, or first_packet_failed if the responder's
+        confirmation got out first. Returns the initiator's outcome. With enters_fallback, the
+        failure completes a streak and the initiator also counts fallback."""
+        initiator, responder = self.nodes[a], self.nodes[b]
+        before_initiator, before_responder = self.handshakes(initiator), self.handshakes(responder)
+        initiator.addnode(f"127.0.0.1:{p2p_port(b)}", "onetry")
+        self.wait_for_handshakes(responder, before_responder, {"inbound": {"switched": 1, "first_packet_failed": 1}})
+        outcomes = ["closed_after_switch", "first_packet_failed"]
+        fallback = {"fallback": 1} if enters_fallback else {}
+        matched = self.wait_for_handshakes(initiator, before_initiator,
+                                           *[{"outbound": {"switched": 1, outcome: 1, **fallback}} for outcome in outcomes])
+        self.wait_for_no_peers(initiator, responder)
+        return outcomes[matched]
+
+    def test_configuration(self):
+        node0, node1, _ = self.nodes
+
+        self.log.info("Test the switch is off by default")
+        assert_equal(self.startup_line(node0)[0], DISABLED_PQ)
+        assert_equal(self.startup_line(node1)[0], DISABLED_PQ)
+        self.check_connection(hybrid=False)
+
+        self.log.info("Test -v2pqtransport=1 on one side only keeps the ECDH keys")
+        with node0.assert_debug_log(["v2 pq: legacy_peer reason=no_features role=initiator"]):
+            self.restart_node(0, extra_args=PQ)
+            assert_equal(self.startup_line(node0)[0], ENABLED)
+            self.check_connection(hybrid=False)
+
+        self.log.info("Test v2pqtransport=1 in qbit.conf, with the command line's on the other side")
+        append_config(node1.datadir_path, ["v2pqtransport=1"])
+        self.restart_node(1)
+        assert_equal(self.startup_line(node1)[0], ENABLED)
+        self.check_connection(hybrid=True)
+
+        self.log.info("Test -nov2pqtransport overrides qbit.conf")
+        with node0.assert_debug_log(["v2 pq: legacy_peer reason=no_features role=initiator"]):
+            self.restart_node(1, extra_args=["-v2transport=1", "-nov2pqtransport"])
+            assert_equal(self.startup_line(node1)[0], DISABLED_PQ)
+            self.check_connection(hybrid=False)
+
+        self.log.info("Test a restart without it switches back on")
+        self.restart_node(1)
+        assert_equal(self.startup_line(node1)[0], ENABLED)
+        self.check_connection(hybrid=True)
+        node1.replace_in_config([("v2pqtransport=1\n", "")])
+        self.restart_node(1)
+        assert_equal(self.startup_line(node1)[0], DISABLED_PQ)
+
+        self.log.info("Test an explicit -v2pqtransport=1 with -v2transport=0 warns, and has no effect")
+        self.stop_node(0)
+        self.check_start(["-v2transport=0", "-v2pqtransport=1"], DISABLED_V2, expected_stderr=CONTRADICTION_WARNING)
+        # An empty value means 1.
+        self.check_start(["-v2transport=0", "-v2pqtransport"], DISABLED_V2, expected_stderr=CONTRADICTION_WARNING)
+
+        self.log.info("Test an explicit -v2pqtransport=0, or -v2transport=0 alone, doesn't warn")
+        self.check_start(["-v2transport=0", "-v2pqtransport=0"], DISABLED_V2)
+        self.check_start(["-v2transport=0", "-nov2pqtransport"], DISABLED_V2)
+        self.check_start(["-v2transport=0"], DISABLED_V2)
+
+        self.log.info("Test a non-numeric -v2pqtransport warns with the value given, what it was read as, and the effect")
+        for value in ["true", "yes", "on"]:
+            self.check_start(["-v2transport=1", f"-v2pqtransport={value}"], DISABLED_PQ,
+                             expected_stderr=non_numeric_warning(value, 0, PQ_OFF))
+        self.check_start(["-v2transport=1", "-v2pqtransport=1abc"], ENABLED, expected_stderr=non_numeric_warning("1abc", 1, PQ_ON))
+        # Out of range: read as 1, the saturated value.
+        self.check_start(["-v2transport=1", "-v2pqtransport=99999999999"], ENABLED,
+                         expected_stderr=non_numeric_warning("99999999999", 1, PQ_ON))
+        # Whitespace and a sign are allowed, as InterpretBool reads them.
+        for value in [" 1", "+1", "-1"]:
+            self.check_start(["-v2transport=1", f"-v2pqtransport={value}"], ENABLED)
+        # With v2 off the effect is off, and the contradiction warns too.
+        self.check_start(["-v2transport=0", "-v2pqtransport=1abc"], DISABLED_V2,
+                         expected_stderr=non_numeric_warning("1abc", 1, PQ_OFF) + os.linesep + CONTRADICTION_WARNING)
+
+        self.log.info("Test a double negative, which switches the hybrid transport on, warns")
+        for value in ["0", "true", "on"]:
+            self.check_start(["-v2transport=1", f"-nov2pqtransport={value}"], ENABLED, expected_stderr=double_negative_warning(PQ_ON))
+        self.check_start(["-v2transport=0", "-nov2pqtransport=true"], DISABLED_V2,
+                         expected_stderr=double_negative_warning(PQ_OFF) + os.linesep + CONTRADICTION_WARNING)
+        append_config(node0.datadir_path, ["nov2pqtransport=true"])
+        self.check_start(["-v2transport=1"], ENABLED, expected_stderr=double_negative_warning(PQ_ON))
+        node0.replace_in_config([("nov2pqtransport=true\n", "")])
+
+        self.log.info("Test -nov2pqtransport and -nov2pqtransport=1 switch it off without a warning")
+        # ArgsManager keeps only a negation's result, so -nov2pqtransport=1abc, read as off like
+        # -nov2pqtransport, can't warn.
+        for option in ["-nov2pqtransport", "-nov2pqtransport=1", "-nov2pqtransport=1abc"]:
+            self.check_start(["-v2transport=1", option], DISABLED_PQ)
+
+        self.log.info("Test -help lists -v2pqtransport, and -help-debug the hidden options")
+        help_text = subprocess.run(node0.binaries.node_argv() + ["-help"], capture_output=True, text=True, check=True).stdout
+        assert "  -v2pqtransport\n" in help_text
+        assert "-mlkemportable" not in help_text
+        help_debug = subprocess.run(node0.binaries.node_argv() + ["-help-debug"], capture_output=True, text=True, check=True).stdout
+        assert "  -mlkemportable\n" in help_debug
+        for option in ["pq_fail_first_packet (", "mlkem_portable ("]:
+            assert option in help_debug
+
+        self.start_node(0)
+
+    def test_portable_options(self):
+        node0 = self.nodes[0]
+
+        self.log.info("Test -mlkemportable and -test=mlkem_portable select portable code")
+        for option in ["-mlkemportable", "-test=mlkem_portable"]:
+            self.restart_node(0, extra_args=["-v2transport=1", option])
+            assert_equal(self.startup_line(node0)[1:], ("portable", "portable"))
+            info = node0.getpqtransportinfo()
+            assert_equal((info["arith_backend"], info["keccak_backend"]), ("portable", "portable"))
+        self.stop_node(0)
+
+        self.log.info("Test a default node runs native code where this build and CPU have it")
+        default = self.check_start(["-v2transport=1"], DISABLED_PQ)[1:]
+        expected = expected_default_backends(self.config)
+        if expected is None:
+            self.log.info("This test can't tell which code runs here by default; not checked")
+        else:
+            assert_equal(default, expected)
+
+        self.log.info("Test a non-numeric -mlkemportable, or a double negative, warns and states which code runs")
+        # -mlkemportable=true is read as 0: the default code stays.
+        assert_equal(self.check_start(["-v2transport=1", "-mlkemportable=true"], DISABLED_PQ,
+                                      expected_stderr=non_numeric_warning("true", 0, NATIVE, "mlkemportable"))[1:], default)
+        assert_equal(self.check_start(["-v2transport=1", "-mlkemportable=1abc"], DISABLED_PQ,
+                                      expected_stderr=non_numeric_warning("1abc", 1, PORTABLE, "mlkemportable"))[1:], ("portable", "portable"))
+        for value in ["0", "true"]:
+            assert_equal(self.check_start(["-v2transport=1", f"-nomlkemportable={value}"], DISABLED_PQ,
+                                          expected_stderr=double_negative_warning(PORTABLE, "mlkemportable"))[1:], ("portable", "portable"))
+        for option in ["-nomlkemportable", "-nomlkemportable=1", "-mlkemportable=0"]:
+            assert_equal(self.check_start(["-v2transport=1", option], DISABLED_PQ)[1:], default)
+        # The test option forces portable code, whatever -mlkemportable is read as; the effect says so.
+        assert_equal(self.check_start(["-v2transport=1", "-mlkemportable=true", "-test=mlkem_portable"], DISABLED_PQ,
+                                      expected_stderr=non_numeric_warning("true", 0, PORTABLE, "mlkemportable"))[1:], ("portable", "portable"))
+        self.start_node(0)
+
+        self.log.info("Test -test=pq_fail_first_packet starts cleanly")
+        self.restart_node(0, extra_args=PQ_FAIL)
+        assert_equal(self.startup_line(node0)[0], ENABLED)
+        # Nothing is printed to stderr (checked at stop).
+        self.stop_node(0)
+
+        self.log.info("Test the test options are regtest only, and -mlkemportable works on any chain")
+        conf_file = node0.datadir_path / "qbit.conf"
+        regtest_conf = conf_file.read_text(encoding="utf-8")
+        write_config(conf_file, n=0, chain="signet")
+        node0.chain = "signet"
+        for option in ["-test=mlkem_portable", "-test=pq_fail_first_packet"]:
+            node0.assert_start_raises_init_error(extra_args=[option], expected_msg=TEST_OPTION_ERROR)
+        self.start_node(0, extra_args=["-v2transport=1", "-mlkemportable"])
+        assert_equal(self.startup_line(node0), (DISABLED_PQ, "portable", "portable"))
+        self.stop_node(0)
+        conf_file.write_text(regtest_conf, encoding="utf-8")
+        node0.chain = "regtest"
+        self.start_node(0)
+
+    def check_info(self, node, *, start_time, enabled, status, **expected):
+        """Check every getpqtransportinfo field: the configuration, the backends the startup line
+        named, since, and the given fields (none counted, empty and inactive unless given)."""
+        info = node.getpqtransportinfo()
+        assert re.fullmatch("[0-9a-f]{64}", info.pop("instance_id"))
+        since = info.pop("since")
+        assert start_time <= since <= time.time() + 1
+        _, arith, keccak = self.startup_line(node)
+        assert_equal(info, {
+            "enabled": enabled,
+            "status": status,
+            "arith_backend": arith,
+            "keccak_backend": keccak,
+            "handshakes": expected.get("handshakes", zero_counts()),
+            "load_shedding": {"active": False, "threshold_per_s": 1000, "since": 0},
+            "fallback_set": expected.get("fallback_set", []),
+            "failure_streaks": expected.get("failure_streaks", []),
+            "recent_failures": expected.get("recent_failures", {"inbound": empty_ring(), "outbound": empty_ring()}),
+        })
+
+    def peer(self, node, *, inbound):
+        """The node's only peer of a direction."""
+        peers = [peer for peer in node.getpeerinfo() if peer["inbound"] == inbound]
+        assert_equal(len(peers), 1)
+        return peers[0]
+
+    def check_peers(self, a, b, status_a, status_b, **kwargs):
+        """Connect node a to node b and check each side's transport_pq_status; then disconnect."""
+        self.connect_nodes(a, b, **kwargs)
+        for node, status, inbound in [(self.nodes[a], status_a, False), (self.nodes[b], status_b, True)]:
+            peer = self.peer(node, inbound=inbound)
+            assert_equal((peer["transport_pq"], peer["transport_pq_status"]), (status == "hybrid", status))
+        self.disconnect_nodes(a, b)
+
+    def test_states(self):
+        node0, node1, node2 = self.nodes
+
+        self.log.info("Test getpqtransportinfo with the switch off; getpeerinfo off on both sides")
+        start_time = int(time.time())
+        self.restart_node(0, extra_args=NO_PQ)
+        self.check_info(node0, start_time=start_time, enabled=False, status="disabled_v2pqtransport")
+        instance_ids = [node0.getpqtransportinfo()["instance_id"]]
+        self.check_peers(0, 2, "off", "off")
+
+        self.log.info("Test getpqtransportinfo with v2 off and the switch off: status names v2")
+        start_time = int(time.time())
+        self.restart_node(0, extra_args=["-v2transport=0"])
+        self.check_info(node0, start_time=start_time, enabled=False, status="disabled_v2transport")
+        instance_ids.append(node0.getpqtransportinfo()["instance_id"])
+
+        self.log.info("Test getpqtransportinfo with v2 off; getpeerinfo v1 on both sides")
+        start_time = int(time.time())
+        self.restart_node(0, extra_args=["-v2transport=0", "-v2pqtransport=1"])
+        self.check_info(node0, start_time=start_time, enabled=False, status="disabled_v2transport")
+        instance_ids.append(node0.getpqtransportinfo()["instance_id"])
+        self.check_peers(0, 2, "v1", "v1", peer_advertises_v2=False)
+        self.stop_node(0, expected_stderr=CONTRADICTION_WARNING)
+
+        self.log.info("Test getpqtransportinfo with the switch on; getpeerinfo hybrid, legacy_peer and off")
+        start_time = int(time.time())
+        self.start_node(0, extra_args=PQ)
+        self.restart_node(1, extra_args=PQ)
+        self.check_info(node0, start_time=start_time, enabled=True, status="enabled")
+        instance_ids.append(node0.getpqtransportinfo()["instance_id"])
+        self.check_peers(0, 1, "hybrid", "hybrid")
+        self.check_peers(0, 2, "legacy_peer", "off")
+        self.check_peers(2, 0, "off", "legacy_peer")
+
+        self.log.info("Test instance_id changes on restart")
+        assert_equal(len(set(instance_ids)), len(instance_ids))
+
+        self.log.info("Test getpqtransportinfo with an endpoint in the fallback set")
+        start_time = int(time.time())
+        self.restart_node(0, extra_args=PQ)
+        self.restart_node(1, extra_args=PQ_FAIL)
+        now = int(time.time())
+        node0.setmocktime(now)
+        endpoint = local_endpoint(p2p_port(1))
+        reasons = {"closed_after_switch": ["eof", "reset"], "first_packet_failed": ["length", "tag"]}
+        outcomes = []
+        for streak in range(1, 4):
+            outcomes.append(self.failing_connection(0, 1, enters_fallback=streak == 3))
+            info = node0.getpqtransportinfo()
+            if streak < 3:
+                assert_equal(info["fallback_set"], [])
+                assert_equal(len(info["failure_streaks"]), 1)
+                assert info["failure_streaks"][0]["reason"] in reasons[outcomes[-1]]
+                assert_equal(info["failure_streaks"], [{"endpoint": endpoint, "cause": outcomes[-1], "reason": info["failure_streaks"][0]["reason"],
+                                                        "streak": streak, "last_failure": now, "next_window_seconds": FIRST_WINDOW}])
+        entries = info["recent_failures"]["outbound"]["entries"]
+        assert_equal(len(entries), 4)
+        for outcome, entry in zip(outcomes, entries):
+            assert entry["reason"] in reasons[outcome]
+        # The fallback entry names the failure that completed the streak, on the same connection.
+        assert_equal((entries[3]["reason"], entries[3]["peer_id"]), (outcomes[-1], entries[2]["peer_id"]))
+        assert entries[0]["peer_id"] < entries[1]["peer_id"] < entries[2]["peer_id"]
+        expected_entries = [{"sequence": sequence, "time": now, "endpoint": endpoint, "direction": "outbound", "connection_type": "manual",
+                             "peer_id": entry["peer_id"], "outcome": outcome, "reason": entry["reason"]}
+                            for sequence, (outcome, entry) in enumerate(zip(outcomes + ["fallback"], entries), start=1)]
+        counts = zero_counts()
+        counts["outbound"]["switched"] = 3
+        for outcome in outcomes:
+            counts["outbound"][outcome] += 1
+        counts["outbound"]["fallback"] = 1
+        self.check_info(node0, start_time=start_time, enabled=True, status="enabled",
+                        handshakes=counts,
+                        fallback_set=[{"endpoint": endpoint, "cause": outcomes[-1], "reason": entries[2]["reason"], "streak": 3,
+                                       "entered": now, "expires": now + FIRST_WINDOW, "window_seconds": FIRST_WINDOW}],
+                        failure_streaks=[],
+                        recent_failures={"inbound": empty_ring(), "outbound": {"last_sequence": 4, "dropped": 0, "entries": expected_entries}})
+
+        self.log.info("Test a connection to an endpoint in the fallback set runs plain v2: getpeerinfo fallback")
+        self.check_peers(0, 1, "fallback", "legacy_peer")
+        node0.setmocktime(0)
+
+    def test_counts(self):
+        node0, node1, node2 = self.nodes
+        self.restart_node(0, extra_args=PQ)
+        self.restart_node(1, extra_args=PQ)
+        self.restart_node(2, extra_args=NO_PQ)
+
+        self.log.info("Test a hybrid connection counts one switch on each side, and the same hybrid session id")
+        before0, before1 = self.handshakes(node0), self.handshakes(node1)
+        self.connect_nodes(0, 1)
+        self.wait_for_handshakes(node0, before0, {"outbound": {"switched": 1}})
+        self.wait_for_handshakes(node1, before1, {"inbound": {"switched": 1}})
+        out_peer, in_peer = self.peer(node0, inbound=False), self.peer(node1, inbound=True)
+        for peer in [out_peer, in_peer]:
+            assert_equal((peer["transport_protocol_type"], peer["transport_pq"], peer["transport_pq_status"]), ("v2", True, "hybrid"))
+        assert re.fullmatch("[0-9a-f]{64}", out_peer["session_id"])
+        assert_equal(out_peer["session_id"], in_peer["session_id"])
+        self.disconnect_nodes(0, 1)
+        # Our own close of a confirmed connection counts nothing more.
+        self.wait_for_handshakes(node0, before0, {"outbound": {"switched": 1}})
+        self.wait_for_handshakes(node1, before1, {"inbound": {"switched": 1}})
+
+        self.log.info("Test a legacy peer counts legacy_peer, in each direction; the side with the switch off counts nothing")
+        before0, before2 = self.handshakes(node0), self.handshakes(node2)
+        self.connect_nodes(0, 2)
+        self.disconnect_nodes(0, 2)
+        self.connect_nodes(2, 0)
+        self.disconnect_nodes(2, 0)
+        self.wait_for_handshakes(node0, before0, {"outbound": {"legacy_peer": 1}, "inbound": {"legacy_peer": 1}})
+        assert_equal(self.handshakes(node2), before2)
+        ring = node0.getpqtransportinfo()["recent_failures"]
+        for direction in ["inbound", "outbound"]:
+            assert_equal((ring[direction]["entries"][-1]["outcome"], ring[direction]["entries"][-1]["reason"]), ("legacy_peer", "no_features"))
+
+        self.log.info("Test -test=pq_fail_first_packet fails hybrid handshakes in both directions")
+        self.restart_node(1, extra_args=PQ_FAIL)
+        before0, before1 = self.handshakes(node0), self.handshakes(node1)
+        out0 = self.failing_connection(0, 1)
+        out1 = self.failing_connection(1, 0)
+        self.wait_for_handshakes(node0, before0, {"outbound": {"switched": 1, out0: 1}, "inbound": {"switched": 1, "first_packet_failed": 1}})
+        self.wait_for_handshakes(node1, before1, {"outbound": {"switched": 1, out1: 1}, "inbound": {"switched": 1, "first_packet_failed": 1}})
+        for node, peer_port, outcome in [(node0, p2p_port(1), out0), (node1, p2p_port(0), out1)]:
+            rings = node.getpqtransportinfo()["recent_failures"]
+            outbound, inbound = rings["outbound"]["entries"][-1], rings["inbound"]["entries"][-1]
+            assert_equal((outbound["outcome"], outbound["direction"], outbound["endpoint"]), (outcome, "outbound", local_endpoint(peer_port)))
+            assert_equal((inbound["outcome"], inbound["direction"], inbound["connection_type"]), ("first_packet_failed", "inbound", "inbound"))
+            assert inbound["reason"] in ["length", "tag"]
+        self.restart_node(1, extra_args=PQ)
+
+    def test_abandoned(self):
+        node0 = self.nodes[0]
+
+        self.log.info("Test an initiator that reads the offer and closes counts one abandoned offer (eof)")
+        self.restart_node(0, extra_args=PQ)
+        reader = OfferReader(p2p_port(0))
+        contents = reader.read_version_contents()
+        assert_equal((len(contents), contents[:4]), (OFFER_LEN, OFFER_PREFIX))
+        peer = self.peer(node0, inbound=True)
+        assert_equal((peer["transport_protocol_type"], peer["transport_pq"], peer["transport_pq_status"], peer["session_id"]),
+                     ("detecting", False, "pending", ""))
+        reader.close()
+        self.wait_for_no_peers(node0)
+        self.wait_for_handshakes(node0, zero_counts(), {"inbound": {"abandoned": 1}})
+        entry = node0.getpqtransportinfo()["recent_failures"]["inbound"]["entries"][-1]
+        entry.pop("time")
+        assert_equal(entry, {"sequence": 1, "endpoint": local_endpoint(reader.local_port), "direction": "inbound",
+                             "connection_type": "inbound", "peer_id": peer["id"], "outcome": "abandoned", "reason": "eof"})
+
+        self.log.info("Test an initiator that stalls after reading the offer counts one abandoned offer (timeout)")
+        self.restart_node(0, extra_args=PQ + ["-peertimeout=3"])
+        reader = OfferReader(p2p_port(0))
+        assert_equal(len(reader.read_version_contents()), OFFER_LEN)
+        self.wait_for_no_peers(node0)
+        self.wait_for_handshakes(node0, zero_counts(), {"inbound": {"abandoned": 1}})
+        assert_equal(node0.getpqtransportinfo()["recent_failures"]["inbound"]["entries"][-1]["reason"], "timeout")
+        reader.close()
+
+    def test_rings(self):
+        node0 = self.nodes[0]
+        self.restart_node(0, extra_args=PQ)
+        self.restart_node(1, extra_args=PQ_FAIL)
+
+        self.log.info("Test inbound failures don't evict the outbound ring's entry")
+        self.failing_connection(0, 1)
+        outbound = node0.getpqtransportinfo()["recent_failures"]["outbound"]
+        assert_equal((outbound["last_sequence"], outbound["dropped"], len(outbound["entries"])), (1, 0, 1))
+        inbound = node0.getpqtransportinfo()["recent_failures"]["inbound"]
+        assert_equal(inbound, empty_ring())
+        failures = 300
+        with ThreadPoolExecutor(max_workers=8) as executor:
+            list(executor.map(abandon_offer, [p2p_port(0)] * failures))
+        self.wait_for_no_peers(node0)
+        self.wait_until(lambda: node0.getpqtransportinfo()["handshakes"]["inbound"]["abandoned"] == failures)
+        rings = node0.getpqtransportinfo()["recent_failures"]
+        assert_equal(rings["outbound"], outbound)
+
+        self.log.info("Test the inbound ring keeps the newest 256 entries, oldest first, with contiguous sequences")
+        inbound = rings["inbound"]
+        assert_equal((inbound["last_sequence"], inbound["dropped"], len(inbound["entries"])), (failures, failures - RING_SIZE, RING_SIZE))
+        assert_equal([entry["sequence"] for entry in inbound["entries"]], list(range(failures - RING_SIZE + 1, failures + 1)))
+        assert_equal({(entry["outcome"], entry["direction"]) for entry in inbound["entries"]}, {("abandoned", "inbound")})
+        self.restart_node(1, extra_args=PQ)
+
+    def outbound_failure(self, dest):
+        """Node 0 connects to dest, which ends at node 1, whose confirmation check fails. Returns node 0's
+        outbound ring entry."""
+        node0, node1, _ = self.nodes
+        before = self.handshakes(node0)
+        node0.addnode(dest, "onetry")
+        self.wait_for_handshakes(node0, before, *[{"outbound": {"switched": 1, outcome: 1}}
+                                                  for outcome in ["closed_after_switch", "first_packet_failed"]])
+        self.wait_for_no_peers(node0, node1)
+        return node0.getpqtransportinfo()["recent_failures"]["outbound"]["entries"][-1]
+
+    def test_endpoints(self):
+        node0, node1, _ = self.nodes
+        self.restart_node(1, extra_args=PQ_FAIL)
+
+        self.log.info("Test a name-proxy destination is accounted to its normalized hostname and port")
+        proxy_port = p2p_port(self.num_nodes)
+        conf = Socks5Configuration()
+        conf.addr = ("127.0.0.1", proxy_port)
+        conf.unauth = True
+        conf.auth = True
+        # The proxy resolves every name to node 1.
+        conf.destinations_factory = lambda addr, port: {"actual_to_addr": "127.0.0.1", "actual_to_port": p2p_port(1)}
+        proxy = Socks5Server(conf)
+        proxy.start()
+        self.restart_node(0, extra_args=PQ + [f"-proxy=127.0.0.1:{proxy_port}"])
+        endpoint = {"kind": "name_proxy", "network": "name_proxy", "address": "pqtest.example", "port": 8333}
+        entry = self.outbound_failure("PQTest.Example.:8333")
+        assert_equal((entry["endpoint"], entry["connection_type"]), (endpoint, "manual"))
+        assert_equal([streak["endpoint"] for streak in node0.getpqtransportinfo()["failure_streaks"]], [endpoint])
+        proxy.stop()
+
+        if not test_ipv6_local():
+            self.log.info("Skipping the IPv6 endpoint: no local IPv6")
+        else:
+            self.log.info("Test an IPv6 endpoint is accounted to its address and port, on both sides")
+            # Node 1 listens on ::1 too, besides qbit.conf's 127.0.0.1.
+            self.restart_node(1, extra_args=PQ_FAIL + ["-bind=[::1]"])
+            self.restart_node(0, extra_args=PQ)
+            entry = self.outbound_failure(f"[::1]:{p2p_port(1)}")
+            assert_equal(entry["endpoint"], {"kind": "address", "network": "ipv6", "address": "::1", "port": p2p_port(1)})
+            inbound = node1.getpqtransportinfo()["recent_failures"]["inbound"]["entries"][-1]["endpoint"]
+            assert_equal((inbound["kind"], inbound["network"], inbound["address"]), ("address", "ipv6", "::1"))
+        self.restart_node(1, extra_args=PQ)
+
+    def test_connection_count(self):
+        node0, node1, node2 = self.nodes
+
+        self.log.info("Test connections_pq counts the hybrid peers getpeerinfo shows")
+        self.restart_node(0, extra_args=PQ)
+        self.restart_node(1, extra_args=PQ)
+        self.connect_nodes(0, 1)
+        self.connect_nodes(0, 2)
+        peers = node0.getpeerinfo()
+        assert_equal(len(peers), 2)
+        assert_equal(sum(peer["transport_pq"] for peer in peers), 1)
+        networkinfo = node0.getnetworkinfo()
+        assert_equal((networkinfo["connections"], networkinfo["connections_pq"]), (2, 1))
+        assert_equal(node1.getnetworkinfo()["connections_pq"], 1)
+        assert_equal(node2.getnetworkinfo()["connections_pq"], 0)
+        self.disconnect_nodes(0, 1)
+        self.disconnect_nodes(0, 2)
+
+        self.log.info("Test connections_pq is 0 with the switch off")
+        self.restart_node(0, extra_args=NO_PQ)
+        self.connect_nodes(0, 1)
+        self.connect_nodes(0, 2)
+        assert_equal(sum(peer["transport_pq"] for peer in node0.getpeerinfo()), 0)
+        networkinfo = node0.getnetworkinfo()
+        assert_equal((networkinfo["connections"], networkinfo["connections_pq"]), (2, 0))
+
+    def run_test(self):
+        self.test_configuration()
+        self.test_portable_options()
+        self.test_states()
+        self.test_counts()
+        self.test_abandoned()
+        self.test_rings()
+        self.test_endpoints()
+        self.test_connection_count()
+
+
+if __name__ == '__main__':
+    PQTransportTest(__file__).main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index c926d3a005..eaf80f64fa 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -255,6 +255,7 @@
     'p2p_block_notfound.py',
     'rpc_net.py --v1transport',
     'rpc_net.py --v2transport',
+    'rpc_pqtransport.py',
     'wallet_keypool.py',
     'wallet_descriptor.py',
     'p2p_nobloomfilter_messages.py',