diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index accc271..2b4d04c 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -211,6 +211,7 @@
 
 QuicConnection::QuicConnection(
     QuicConnectionId server_connection_id,
+    QuicSocketAddress initial_self_address,
     QuicSocketAddress initial_peer_address,
     QuicConnectionHelperInterface* helper,
     QuicAlarmFactory* alarm_factory,
@@ -237,6 +238,10 @@
       server_connection_id_(server_connection_id),
       client_connection_id_(EmptyQuicConnectionId()),
       client_connection_id_is_set_(false),
+      self_address_(
+          GetQuicReloadableFlag(quic_connection_set_initial_self_address)
+              ? initial_self_address
+              : QuicSocketAddress()),
       peer_address_(initial_peer_address),
       direct_peer_address_(initial_peer_address),
       active_effective_peer_migration_type_(NO_CHANGE),
@@ -319,6 +324,11 @@
                              alarm_factory_),
       support_handshake_done_(version().HasHandshakeDone()) {
   QUIC_BUG_IF(!start_peer_migration_earlier_ && send_path_response_);
+  if (GetQuicReloadableFlag(quic_connection_set_initial_self_address)) {
+    DCHECK(perspective_ == Perspective::IS_CLIENT ||
+           self_address_.IsInitialized());
+    QUIC_RELOADABLE_FLAG_COUNT(quic_connection_set_initial_self_address);
+  }
   if (fix_missing_connected_checks_) {
     QUIC_RELOADABLE_FLAG_COUNT(quic_add_missing_connected_checks);
   }
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 37c9801..0617478 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -417,6 +417,7 @@
   // specifies whether the connection takes ownership of |writer|. |helper| must
   // outlive this connection.
   QuicConnection(QuicConnectionId server_connection_id,
+                 QuicSocketAddress initial_self_address,
                  QuicSocketAddress initial_peer_address,
                  QuicConnectionHelperInterface* helper,
                  QuicAlarmFactory* alarm_factory,
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 04601c1..0fa0b49 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -181,14 +181,16 @@
 class TestConnection : public QuicConnection {
  public:
   TestConnection(QuicConnectionId connection_id,
-                 QuicSocketAddress address,
+                 QuicSocketAddress initial_self_address,
+                 QuicSocketAddress initial_peer_address,
                  TestConnectionHelper* helper,
                  TestAlarmFactory* alarm_factory,
                  TestPacketWriter* writer,
                  Perspective perspective,
                  ParsedQuicVersion version)
       : QuicConnection(connection_id,
-                       address,
+                       initial_self_address,
+                       initial_peer_address,
                        helper,
                        alarm_factory,
                        writer,
@@ -593,6 +595,7 @@
         writer_(
             new TestPacketWriter(version(), &clock_, Perspective::IS_CLIENT)),
         connection_(connection_id_,
+                    kSelfAddress,
                     kPeerAddress,
                     helper_.get(),
                     alarm_factory_.get(),
@@ -1510,6 +1513,7 @@
   QuicIpAddress host;
   host.FromString("1.1.1.1");
   QuicSocketAddress self_address1(host, 443);
+  connection_.SetSelfAddress(self_address1);
   ProcessFramePacketWithAddresses(MakeCryptoFrame(), self_address1,
                                   kPeerAddress, ENCRYPTION_INITIAL);
   // Cause self_address change to mapped Ipv4 address.
@@ -2229,8 +2233,8 @@
 }
 
 TEST_P(QuicConnectionTest, SmallerServerMaxPacketSize) {
-  TestConnection connection(TestConnectionId(), kPeerAddress, helper_.get(),
-                            alarm_factory_.get(), writer_.get(),
+  TestConnection connection(TestConnectionId(), kSelfAddress, kPeerAddress,
+                            helper_.get(), alarm_factory_.get(), writer_.get(),
                             Perspective::IS_SERVER, version());
   EXPECT_EQ(Perspective::IS_SERVER, connection.perspective());
   EXPECT_EQ(1000u, connection.max_packet_length());
@@ -2344,8 +2348,8 @@
   const QuicConnectionId connection_id = TestConnectionId(17);
   const QuicByteCount lower_max_packet_size = 1240;
   writer_->set_max_packet_size(lower_max_packet_size);
-  TestConnection connection(connection_id, kPeerAddress, helper_.get(),
-                            alarm_factory_.get(), writer_.get(),
+  TestConnection connection(connection_id, kSelfAddress, kPeerAddress,
+                            helper_.get(), alarm_factory_.get(), writer_.get(),
                             Perspective::IS_CLIENT, version());
   EXPECT_EQ(Perspective::IS_CLIENT, connection.perspective());
   EXPECT_EQ(lower_max_packet_size, connection.max_packet_length());
@@ -6829,11 +6833,11 @@
 }
 
 TEST_P(QuicConnectionTest, Pacing) {
-  TestConnection server(connection_id_, kSelfAddress, helper_.get(),
-                        alarm_factory_.get(), writer_.get(),
+  TestConnection server(connection_id_, kPeerAddress, kSelfAddress,
+                        helper_.get(), alarm_factory_.get(), writer_.get(),
                         Perspective::IS_SERVER, version());
-  TestConnection client(connection_id_, kPeerAddress, helper_.get(),
-                        alarm_factory_.get(), writer_.get(),
+  TestConnection client(connection_id_, kSelfAddress, kPeerAddress,
+                        helper_.get(), alarm_factory_.get(), writer_.get(),
                         Perspective::IS_CLIENT, version());
   EXPECT_FALSE(QuicSentPacketManagerPeer::UsingPacing(
       static_cast<const QuicSentPacketManager*>(
diff --git a/quic/masque/masque_dispatcher.cc b/quic/masque/masque_dispatcher.cc
index ff9d2cf..098090a 100644
--- a/quic/masque/masque_dispatcher.cc
+++ b/quic/masque/masque_dispatcher.cc
@@ -28,15 +28,16 @@
 
 std::unique_ptr<QuicSession> MasqueDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
-    const QuicSocketAddress& /*self_address*/,
+    const QuicSocketAddress& self_address,
     const QuicSocketAddress& peer_address,
     quiche::QuicheStringPiece /*alpn*/,
     const ParsedQuicVersion& version) {
   // The MasqueServerSession takes ownership of |connection| below.
-  QuicConnection* connection = new QuicConnection(
-      connection_id, peer_address, helper(), alarm_factory(), writer(),
-      /*owns_writer=*/false, Perspective::IS_SERVER,
-      ParsedQuicVersionVector{version});
+  QuicConnection* connection =
+      new QuicConnection(connection_id, self_address, peer_address, helper(),
+                         alarm_factory(), writer(),
+                         /*owns_writer=*/false, Perspective::IS_SERVER,
+                         ParsedQuicVersionVector{version});
 
   auto session = std::make_unique<MasqueServerSession>(
       config(), GetSupportedVersions(), connection, this, this,
diff --git a/quic/qbone/qbone_client_test.cc b/quic/qbone/qbone_client_test.cc
index cfe6c46..5a637a2 100644
--- a/quic/qbone/qbone_client_test.cc
+++ b/quic/qbone/qbone_client_test.cc
@@ -123,13 +123,13 @@
 
   std::unique_ptr<QuicSession> CreateQuicSession(
       QuicConnectionId id,
-      const QuicSocketAddress& /*self_address*/,
+      const QuicSocketAddress& self_address,
       const QuicSocketAddress& peer_address,
       quiche::QuicheStringPiece alpn,
       const quic::ParsedQuicVersion& version) override {
     CHECK_EQ(alpn, "qbone");
     QuicConnection* connection = new QuicConnection(
-        id, peer_address, helper(), alarm_factory(), writer(),
+        id, self_address, peer_address, helper(), alarm_factory(), writer(),
         /* owns_writer= */ false, Perspective::IS_SERVER,
         ParsedQuicVersionVector{version});
     // The connection owning wrapper owns the connection created.
diff --git a/quic/qbone/qbone_session_test.cc b/quic/qbone/qbone_session_test.cc
index 243a5c5..31129c2 100644
--- a/quic/qbone/qbone_session_test.cc
+++ b/quic/qbone/qbone_session_test.cc
@@ -318,9 +318,9 @@
 
     {
       client_connection_ = new QuicConnection(
-          TestConnectionId(), server_address, &helper_, alarm_factory_.get(),
-          new NiceMock<MockPacketWriter>(), true, Perspective::IS_CLIENT,
-          supported_versions_);
+          TestConnectionId(), client_address, server_address, &helper_,
+          alarm_factory_.get(), new NiceMock<MockPacketWriter>(), true,
+          Perspective::IS_CLIENT, supported_versions_);
       client_connection_->SetSelfAddress(client_address);
       QuicConfig config;
       client_crypto_config_ = std::make_unique<QuicCryptoClientConfig>(
@@ -337,9 +337,9 @@
 
     {
       server_connection_ = new QuicConnection(
-          TestConnectionId(), client_address, &helper_, alarm_factory_.get(),
-          new NiceMock<MockPacketWriter>(), true, Perspective::IS_SERVER,
-          supported_versions_);
+          TestConnectionId(), server_address, client_address, &helper_,
+          alarm_factory_.get(), new NiceMock<MockPacketWriter>(), true,
+          Perspective::IS_SERVER, supported_versions_);
       server_connection_->SetSelfAddress(server_address);
       QuicConfig config;
       server_crypto_config_ = std::make_unique<QuicCryptoServerConfig>(
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index cfe9645..fa43c5b 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -152,6 +152,7 @@
 
     connection_.reset(new QuicConnection(
         test::TestConnectionId(0), QuicSocketAddress(TestLoopback(), 0),
+        QuicSocketAddress(TestLoopback(), 0),
         this /*QuicConnectionHelperInterface*/, alarm_factory_.get(),
         new DummyPacketWriter(), owns_writer, perspective,
         ParsedVersionOfIndex(CurrentSupportedVersions(), 0)));
diff --git a/quic/quic_transport/quic_transport_integration_test.cc b/quic/quic_transport/quic_transport_integration_test.cc
index f1912e2..4a99724 100644
--- a/quic/quic_transport/quic_transport_integration_test.cc
+++ b/quic/quic_transport/quic_transport_integration_test.cc
@@ -62,8 +62,9 @@
       : QuicEndpointBase(simulator, name, peer_name) {
     QuicEnableVersion(DefaultVersionForQuicTransport());
     connection_ = std::make_unique<QuicConnection>(
-        TestConnectionId(0x10), simulator::GetAddressFromName(peer_name),
-        simulator, simulator->GetAlarmFactory(), &writer_,
+        TestConnectionId(0x10), simulator::GetAddressFromName(name),
+        simulator::GetAddressFromName(peer_name), simulator,
+        simulator->GetAlarmFactory(), &writer_,
         /*owns_writer=*/false, perspective, GetVersions());
     connection_->SetSelfAddress(simulator::GetAddressFromName(name));
   }
diff --git a/quic/test_tools/first_flight.cc b/quic/test_tools/first_flight.cc
index e4d2816..665f479 100644
--- a/quic/test_tools/first_flight.cc
+++ b/quic/test_tools/first_flight.cc
@@ -46,6 +46,7 @@
     crypto_config_.set_alpn(AlpnForVersion(version_));
     connection_ =
         new QuicConnection(server_connection_id_,
+                           /*initial_self_address=*/QuicSocketAddress(),
                            QuicSocketAddress(TestPeerIPAddress(), kTestPort),
                            &connection_helper_, &alarm_factory_, &writer_,
                            /*owns_writer=*/false, Perspective::IS_CLIENT,
diff --git a/quic/test_tools/quic_test_server.cc b/quic/test_tools/quic_test_server.cc
index f311079..9d705d3 100644
--- a/quic/test_tools/quic_test_server.cc
+++ b/quic/test_tools/quic_test_server.cc
@@ -106,7 +106,7 @@
           id, self_address, peer_address, alpn, version);
     }
     QuicConnection* connection = new QuicConnection(
-        id, peer_address, helper(), alarm_factory(), writer(),
+        id, self_address, peer_address, helper(), alarm_factory(), writer(),
         /* owns_writer= */ false, Perspective::IS_SERVER,
         ParsedQuicVersionVector{version});
 
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index ed7dc75..6fa77c0 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -525,19 +525,21 @@
 
 MockQuicConnection::MockQuicConnection(
     QuicConnectionId connection_id,
-    QuicSocketAddress address,
+    QuicSocketAddress initial_peer_address,
     MockQuicConnectionHelper* helper,
     MockAlarmFactory* alarm_factory,
     Perspective perspective,
     const ParsedQuicVersionVector& supported_versions)
-    : QuicConnection(connection_id,
-                     address,
-                     helper,
-                     alarm_factory,
-                     new testing::NiceMock<MockPacketWriter>(),
-                     /* owns_writer= */ true,
-                     perspective,
-                     supported_versions) {
+    : QuicConnection(
+          connection_id,
+          /*initial_self_address=*/QuicSocketAddress(QuicIpAddress::Any4(), 5),
+          initial_peer_address,
+          helper,
+          alarm_factory,
+          new testing::NiceMock<MockPacketWriter>(),
+          /* owns_writer= */ true,
+          perspective,
+          supported_versions) {
   ON_CALL(*this, OnError(_))
       .WillByDefault(
           Invoke(this, &PacketSavingConnection::QuicConnection_OnError));
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index 0f04427..c02ac7e 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -34,10 +34,9 @@
       wrong_data_received_(false),
       notifier_(nullptr) {
   connection_ = std::make_unique<QuicConnection>(
-      connection_id, GetAddressFromName(peer_name), simulator,
-      simulator->GetAlarmFactory(), &writer_, false, perspective,
+      connection_id, GetAddressFromName(name), GetAddressFromName(peer_name),
+      simulator, simulator->GetAlarmFactory(), &writer_, false, perspective,
       ParsedVersionOfIndex(CurrentSupportedVersions(), 0));
-  connection_->SetSelfAddress(GetAddressFromName(name));
   connection_->set_visitor(this);
   connection_->SetEncrypter(ENCRYPTION_FORWARD_SECURE,
                             std::make_unique<NullEncrypter>(perspective));
diff --git a/quic/tools/quic_client_base.cc b/quic/tools/quic_client_base.cc
index c1d2ea2..5d89797 100644
--- a/quic/tools/quic_client_base.cc
+++ b/quic/tools/quic_client_base.cc
@@ -121,8 +121,8 @@
 
   session_ = CreateQuicClientSession(
       client_supported_versions,
-      new QuicConnection(GetNextConnectionId(), server_address(), helper(),
-                         alarm_factory(), writer,
+      new QuicConnection(GetNextConnectionId(), QuicSocketAddress(),
+                         server_address(), helper(), alarm_factory(), writer,
                          /* owns_writer= */ false, Perspective::IS_CLIENT,
                          client_supported_versions));
   if (connection_debug_visitor_ != nullptr) {
diff --git a/quic/tools/quic_simple_dispatcher.cc b/quic/tools/quic_simple_dispatcher.cc
index eb06dd5..c5ba63d 100644
--- a/quic/tools/quic_simple_dispatcher.cc
+++ b/quic/tools/quic_simple_dispatcher.cc
@@ -50,15 +50,16 @@
 
 std::unique_ptr<QuicSession> QuicSimpleDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
-    const QuicSocketAddress& /*self_address*/,
+    const QuicSocketAddress& self_address,
     const QuicSocketAddress& peer_address,
     quiche::QuicheStringPiece /*alpn*/,
     const ParsedQuicVersion& version) {
   // The QuicServerSessionBase takes ownership of |connection| below.
-  QuicConnection* connection = new QuicConnection(
-      connection_id, peer_address, helper(), alarm_factory(), writer(),
-      /* owns_writer= */ false, Perspective::IS_SERVER,
-      ParsedQuicVersionVector{version});
+  QuicConnection* connection =
+      new QuicConnection(connection_id, self_address, peer_address, helper(),
+                         alarm_factory(), writer(),
+                         /* owns_writer= */ false, Perspective::IS_SERVER,
+                         ParsedQuicVersionVector{version});
 
   auto session = std::make_unique<QuicSimpleServerSession>(
       config(), GetSupportedVersions(), connection, this, session_helper(),
diff --git a/quic/tools/quic_transport_simple_server_dispatcher.cc b/quic/tools/quic_transport_simple_server_dispatcher.cc
index d445b54..35108c9 100644
--- a/quic/tools/quic_transport_simple_server_dispatcher.cc
+++ b/quic/tools/quic_transport_simple_server_dispatcher.cc
@@ -36,12 +36,13 @@
 std::unique_ptr<QuicSession>
 QuicTransportSimpleServerDispatcher::CreateQuicSession(
     QuicConnectionId server_connection_id,
-    const QuicSocketAddress& /*self_address*/,
+    const QuicSocketAddress& self_address,
     const QuicSocketAddress& peer_address,
     quiche::QuicheStringPiece /*alpn*/,
     const ParsedQuicVersion& version) {
   auto connection = std::make_unique<QuicConnection>(
-      server_connection_id, peer_address, helper(), alarm_factory(), writer(),
+      server_connection_id, self_address, peer_address, helper(),
+      alarm_factory(), writer(),
       /*owns_writer=*/false, Perspective::IS_SERVER,
       ParsedQuicVersionVector{version});
   auto session = std::make_unique<QuicTransportSimpleServerSession>(