diff --git i/src/net_processing.cpp w/src/net_processing.cpp
index d637abcef..ab000da9c 100644
--- i/src/net_processing.cpp
+++ w/src/net_processing.cpp
@@ -1492,14 +1492,14 @@ static void RelayAddress(const CAddress& addr, bool fReachable, const CConnman&
     // Relay reachable addresses to 2 peers. Unreachable addresses are relayed randomly to 1 or 2 peers.
     unsigned int nRelayNodes = (fReachable || (hasher.Finalize() & 1)) ? 2 : 1;
 
     std::array<std::pair<uint64_t, CNode*>,2> best{{{0, nullptr}, {0, nullptr}}};
     assert(nRelayNodes <= best.size());
 
-    auto sortfunc = [&best, &hasher, nRelayNodes](CNode* pnode) {
-        if (pnode->IsAddrRelayPeer()) {
+    auto sortfunc = [&addr, &best, &hasher, nRelayNodes](CNode* pnode) {
+        if (pnode->IsAddrRelayPeer() && !pnode->m_addr_known->contains(addr.GetKey())) {
             uint64_t hashKey = CSipHasher(hasher).Write(pnode->GetId()).Finalize();
             for (unsigned int i = 0; i < nRelayNodes; i++) {
                  if (hashKey > best[i].first) {
                      std::copy(best.begin() + i, best.begin() + nRelayNodes - 1, best.begin() + i + 1);
                      best[i] = std::make_pair(hashKey, pnode);
                      break;
diff --git i/test/functional/p2p_addr_relay.py w/test/functional/p2p_addr_relay.py
index 5c7e27a3a..f7315f97c 100755
--- i/test/functional/p2p_addr_relay.py
+++ w/test/functional/p2p_addr_relay.py
@@ -18,28 +18,56 @@ from test_framework.mininode import (
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
 )
 import time
 
+# Keep this with length <= 10. Addresses from larger messages are not relayed.
 ADDRS = []
-for i in range(10):
+
+num_ipv4_addrs = 5
+for i in range(num_ipv4_addrs):
     addr = CAddress()
     addr.time = int(time.time()) + i
     addr.nServices = NODE_NETWORK | NODE_WITNESS
     addr.ip = "123.123.123.{}".format(i % 256)
     addr.port = 8333 + i
     ADDRS.append(addr)
 
+i = 0
+for tor_addr in [ \
+        "2empatdfea6vwete.onion", \
+        "34aqcwnnuiqh234f.onion", \
+        "3gxqibajrtysyp5o.onion", \
+        "3sami4tg4yhctjyc.onion", \
+        "3w77hrilg6q64opl.onion" \
+    ]:
+    addr = CAddress()
+    addr.time = int(time.time()) + i
+    addr.nServices = NODE_NETWORK | NODE_WITNESS
+    addr.ip = tor_addr
+    addr.port = 8433 + i
+    ADDRS.append(addr)
+    i += 1
+
 
 class AddrReceiver(P2PInterface):
+    num_ipv4_received = 0
+    num_tor_received = 0
+
     def on_addr(self, message):
         for addr in message.addrs:
             assert_equal(addr.nServices, 9)
-            assert addr.ip.startswith('123.123.123.')
-            assert (8333 <= addr.port < 8343)
+            if addr.ip.startswith('123.123.123.'):
+                assert (8333 <= addr.port < 8338)
+                self.num_ipv4_received += 1
+            elif addr.ip.endswith('.onion'):
+                assert (8433 <= addr.port < 8438)
+                self.num_tor_received += 1
+            else:
+                assert False
 
 
 class AddrTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = False
         self.num_nodes = 1
@@ -47,25 +75,39 @@ class AddrTest(BitcoinTestFramework):
     def run_test(self):
         self.log.info('Create connection that sends addr messages')
         addr_source = self.nodes[0].add_p2p_connection(P2PInterface())
         msg = msg_addr()
 
         self.log.info('Send too-large addr message')
-        msg.addrs = ADDRS * 101
+        msg.addrs = ADDRS * 101 # more than 1000 addresses in one message
         with self.nodes[0].assert_debug_log(['addr message size = 1010']):
             addr_source.send_and_ping(msg)
 
-        self.log.info('Check that addr message content is relayed and added to addrman')
-        addr_receiver = self.nodes[0].add_p2p_connection(AddrReceiver())
+        # Every IPv4 address must be relayed to both peers.
+        # Every TOR address must be relayed to just one or both peers.
+        self.log.info('Send normal addr message and check that addresses are relayed and added to addrman')
+        addr_receiver1 = self.nodes[0].add_p2p_connection(AddrReceiver())
+        addr_receiver2 = self.nodes[0].add_p2p_connection(AddrReceiver())
         msg.addrs = ADDRS
         with self.nodes[0].assert_debug_log([
-                'Added 10 addresses from 127.0.0.1: 0 tried',
+                'Added {} addresses from 127.0.0.1: 0 tried'.format(num_ipv4_addrs),
                 'received: addr (301 bytes) peer=0',
-                'sending addr (301 bytes) peer=1',
         ]):
             addr_source.send_and_ping(msg)
             self.nodes[0].setmocktime(int(time.time()) + 30 * 60)
-            addr_receiver.sync_with_ping()
+            addr_receiver1.sync_with_ping()
+            addr_receiver2.sync_with_ping()
+
+        assert addr_receiver1.num_ipv4_received == 5
+        assert addr_receiver2.num_ipv4_received == 5
+
+        assert 0 <= addr_receiver1.num_tor_received <= 5
+        assert 0 <= addr_receiver2.num_tor_received <= 5
+
+        self.log.info('Receiver1 got {} IPv4 and {} TOR addresses'.format(
+                      addr_receiver1.num_ipv4_received, addr_receiver1.num_tor_received))
+        self.log.info('Receiver2 got {} IPv4 and {} TOR addresses'.format(
+                      addr_receiver2.num_ipv4_received, addr_receiver2.num_tor_received))
 
 
 if __name__ == '__main__':
     AddrTest().main()
diff --git i/test/functional/test_framework/messages.py w/test/functional/test_framework/messages.py
index 5207b563a..350bed670 100755
--- i/test/functional/test_framework/messages.py
+++ w/test/functional/test_framework/messages.py
@@ -15,12 +15,13 @@ msg_block, msg_tx, msg_headers, etc.:
 
 ser_*, deser_*: functions that handle serialization/deserialization.
 
 Classes use __slots__ to ensure extraneous attributes aren't accidentally added
 by tests, compromising their intended effect.
 """
+import base64
 from codecs import encode
 import copy
 import hashlib
 from io import BytesIO
 import random
 import socket
@@ -197,44 +198,52 @@ def ToHex(obj):
     return obj.serialize().hex()
 
 # Objects that map to bitcoind objects, which can be serialized/deserialized
 
 
 class CAddress:
-    __slots__ = ("ip", "nServices", "pchReserved", "port", "time")
+    __slots__ = ("ip", "nServices", "pchReserved", "pchOnionCat", "port", "time")
 
     def __init__(self):
         self.time = 0
         self.nServices = 1
         self.pchReserved = b"\x00" * 10 + b"\xff" * 2
+        self.pchOnionCat = b"\xfd\x87\xd8\x7e\xeb\x43"
         self.ip = "0.0.0.0"
         self.port = 0
 
     def deserialize(self, f, *, with_time=True):
         if with_time:
             # VERSION messages serialize CAddress objects without time
             self.time = struct.unpack("<i", f.read(4))[0]
         self.nServices = struct.unpack("<Q", f.read(8))[0]
-        self.pchReserved = f.read(12)
-        self.ip = socket.inet_ntoa(f.read(4))
+        buf = f.read(16)
+        if buf.startswith(self.pchOnionCat):
+            self.ip = base64.b32encode(buf[len(self.pchOnionCat):]).decode().lower() + ".onion"
+        else:
+            self.ip = socket.inet_ntoa(buf[len(self.pchReserved):])
         self.port = struct.unpack(">H", f.read(2))[0]
 
     def serialize(self, *, with_time=True):
         r = b""
         if with_time:
             # VERSION messages serialize CAddress objects without time
             r += struct.pack("<i", self.time)
         r += struct.pack("<Q", self.nServices)
-        r += self.pchReserved
-        r += socket.inet_aton(self.ip)
+        if self.ip.endswith(".onion"):
+            r += self.pchOnionCat
+            r += base64.b32decode(self.ip[:-len(".onion")], casefold=True)
+        else:
+            r += self.pchReserved
+            r += socket.inet_aton(self.ip)
         r += struct.pack(">H", self.port)
         return r
 
     def __repr__(self):
-        return "CAddress(nServices=%i ip=%s port=%i)" % (self.nServices,
-                                                         self.ip, self.port)
+        return "CAddress(nServices=%i addr=%s port=%i)" % (self.nServices,
+                                                           self.ip, self.port)
 
 
 class CInv:
     __slots__ = ("hash", "type")
 
     typemap = {