diff --git a/src/net.h b/src/net.h
--- a/src/net.h
+++ b/src/net.h
@@ -643,6 +643,7 @@
     CAddress addr;
     // Bind address of our side of the connection
     CAddress addrBind;
+    uint32_t m_mapped_as;
 };
 
 class CNetMessage {
@@ -970,7 +971,7 @@
 
     void CloseSocketDisconnect();
 
-    void copyStats(CNodeStats &stats);
+    void copyStats(CNodeStats &stats, std::vector<bool> &m_asmap);
 
     ServiceFlags GetLocalServices() const { return nLocalServices; }
 
diff --git a/src/net.cpp b/src/net.cpp
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -502,11 +502,12 @@
     }
 }
 
-void CNode::copyStats(CNodeStats &stats) {
+void CNode::copyStats(CNodeStats &stats, std::vector<bool> &m_asmap) {
     stats.nodeid = this->GetId();
     stats.nServices = nServices;
     stats.addr = addr;
     stats.addrBind = addrBind;
+    stats.m_mapped_as = addr.GetMappedAS(m_asmap);
     if (m_tx_relay != nullptr) {
         LOCK(m_tx_relay->cs_filter);
         stats.fRelayTxes = m_tx_relay->fRelayTxes;
@@ -2719,7 +2720,7 @@
     vstats.reserve(vNodes.size());
     for (CNode *pnode : vNodes) {
         vstats.emplace_back();
-        pnode->copyStats(vstats.back());
+        pnode->copyStats(vstats.back(), addrman.m_asmap);
     }
 }
 
diff --git a/src/netaddress.h b/src/netaddress.h
--- a/src/netaddress.h
+++ b/src/netaddress.h
@@ -98,6 +98,13 @@
     unsigned int GetByte(int n) const;
     uint64_t GetHash() const;
     bool GetInAddr(struct in_addr *pipv4Addr) const;
+    uint32_t GetNetClass() const;
+
+    // The AS on the BGP path to the node we use to diversify
+    // peers in AddrMan bucketing based on the AS infrastructure.
+    // The ip->AS mapping depends on how asmap is constructed.
+    uint32_t GetMappedAS(const std::vector<bool> &asmap) const;
+
     std::vector<uint8_t> GetGroup(const std::vector<bool> &asmap) const;
     std::vector<uint8_t> GetAddrBytes() const {
         return {std::begin(ip), std::end(ip)};
diff --git a/src/netaddress.cpp b/src/netaddress.cpp
--- a/src/netaddress.cpp
+++ b/src/netaddress.cpp
@@ -404,6 +404,41 @@
     return true;
 }
 
+uint32_t CNetAddr::GetNetClass() const {
+    uint32_t net_class = NET_IPV6;
+    if (IsLocal()) {
+        net_class = 255;
+    }
+    if (IsInternal()) {
+        net_class = NET_INTERNAL;
+    } else if (!IsRoutable()) {
+        net_class = NET_UNROUTABLE;
+    } else if (IsIPv4() || IsRFC6145() || IsRFC6052() || IsRFC3964() ||
+               IsRFC4380()) {
+        net_class = NET_IPV4;
+    } else if (IsTor()) {
+        net_class = NET_ONION;
+    }
+    return net_class;
+}
+
+uint32_t CNetAddr::GetMappedAS(const std::vector<bool> &asmap) const {
+    uint32_t net_class = GetNetClass();
+    if (asmap.size() == 0 || (net_class != NET_IPV4 && net_class != NET_IPV6)) {
+        return 0; // Indicates not found, safe because AS0 is reserved per
+                  // RFC7607.
+    }
+    std::vector<bool> ip_bits(128);
+    for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
+        uint8_t cur_byte = GetByte(15 - byte_i);
+        for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
+            ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
+        }
+    }
+    uint32_t mapped_as = Interpret(asmap, ip_bits);
+    return mapped_as;
+}
+
 /**
  * Get the canonical identifier of our network group
  *
@@ -416,43 +451,50 @@
  */
 std::vector<uint8_t> CNetAddr::GetGroup(const std::vector<bool> &asmap) const {
     std::vector<uint8_t> vchRet;
-    int nClass = NET_IPV6;
+    uint32_t net_class = GetNetClass();
+    // If non-empty asmap is supplied and the address is IPv4/IPv6,
+    // return ASN to be used for bucketing.
+    uint32_t asn = GetMappedAS(asmap);
+    if (asn != 0) { // Either asmap was empty, or address has non-asmappable net
+                    // class (e.g. TOR).
+        vchRet.push_back(NET_IPV6); // IPv4 and IPv6 with same ASN should be in
+                                    // the same bucket
+        for (int i = 0; i < 4; i++) {
+            vchRet.push_back((asn >> (8 * i)) & 0xFF);
+        }
+        return vchRet;
+    }
+
+    vchRet.push_back(net_class);
     int nStartByte = 0;
     int nBits = 16;
 
     // all local addresses belong to the same group
     if (IsLocal()) {
-        nClass = 255;
         nBits = 0;
     }
 
     if (IsInternal()) {
         // all internal-usage addresses get their own group
-        nClass = NET_INTERNAL;
         nStartByte = sizeof(g_internal_prefix);
         nBits = (sizeof(ip) - sizeof(g_internal_prefix)) * 8;
     } else if (!IsRoutable()) {
         // all other unroutable addresses belong to the same group
-        nClass = NET_UNROUTABLE;
         nBits = 0;
     } else if (IsIPv4() || IsRFC6145() || IsRFC6052()) {
         // for IPv4 addresses, '1' + the 16 higher-order bits of the IP includes
         // mapped IPv4, SIIT translated IPv4, and the well-known prefix
-        nClass = NET_IPV4;
         nStartByte = 12;
     } else if (IsRFC3964()) {
         // for 6to4 tunnelled addresses, use the encapsulated IPv4 address
-        nClass = NET_IPV4;
         nStartByte = 2;
     } else if (IsRFC4380()) {
         // for Teredo-tunnelled IPv6 addresses, use the encapsulated IPv4
         // address
-        vchRet.push_back(NET_IPV4);
         vchRet.push_back(GetByte(3) ^ 0xFF);
         vchRet.push_back(GetByte(2) ^ 0xFF);
         return vchRet;
     } else if (IsTor()) {
-        nClass = NET_ONION;
         nStartByte = 6;
         nBits = 4;
     } else if (GetByte(15) == 0x20 && GetByte(14) == 0x01 &&
@@ -464,29 +506,6 @@
         nBits = 32;
     }
 
-    // If asmap is supplied and the address is IPv4/IPv6,
-    // ignore nBits and use 32/128 bits to obtain ASN from asmap.
-    // ASN is then returned to be used for bucketing.
-    if (asmap.size() != 0 && (nClass == NET_IPV4 || nClass == NET_IPV6)) {
-        nClass = NET_IPV6;
-        std::vector<bool> ip_bits(128);
-        for (int8_t byte_i = 0; byte_i < 16; ++byte_i) {
-            uint8_t cur_byte = GetByte(15 - byte_i);
-            for (uint8_t bit_i = 0; bit_i < 8; ++bit_i) {
-                ip_bits[byte_i * 8 + bit_i] = (cur_byte >> (7 - bit_i)) & 1;
-            }
-        }
-
-        uint32_t asn = Interpret(asmap, ip_bits);
-        vchRet.push_back(nClass);
-        for (int i = 0; i < 4; i++) {
-            vchRet.push_back((asn >> (8 * i)) & 0xFF);
-        }
-        return vchRet;
-    }
-
-    vchRet.push_back(nClass);
-
     // push our ip onto vchRet byte by byte...
     while (nBits >= 8) {
         vchRet.push_back(GetByte(15 - nStartByte));
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -100,6 +100,9 @@
                      "(ip:port) Bind address of the connection to the peer"},
                     {RPCResult::Type::STR, "addrlocal",
                      "(ip:port) Local address as reported by the peer"},
+                    {RPCResult::Type::NUM, "mapped_as",
+                     "The AS in the BGP route to the peer used for "
+                     "diversifying peer selection\n"},
                     {RPCResult::Type::STR_HEX, "services",
                      "The services offered"},
                     {RPCResult::Type::ARR,
@@ -205,6 +208,9 @@
         if (stats.addrBind.IsValid()) {
             obj.pushKV("addrbind", stats.addrBind.ToString());
         }
+        if (stats.m_mapped_as != 0) {
+            obj.pushKV("mapped_as", uint64_t(stats.m_mapped_as));
+        }
         obj.pushKV("services", strprintf("%016x", stats.nServices));
         obj.pushKV("servicesnames", GetServicesNames(stats.nServices));
         obj.pushKV("relaytxes", stats.fRelayTxes);