diff --git a/quiche/quic/core/crypto/crypto_protocol.h b/quiche/quic/core/crypto/crypto_protocol.h
index 08dcc42..31937bc 100644
--- a/quiche/quic/core/crypto/crypto_protocol.h
+++ b/quiche/quic/core/crypto/crypto_protocol.h
@@ -285,6 +285,10 @@
                                                  // upon client address change.
 
 const QuicTag kSPAD = TAG('S', 'P', 'A', 'D');   // Use server preferred address
+const QuicTag kSPA2 = TAG('S', 'P', 'A', '2');   // Start validating server
+                                                 // preferred address once it is
+                                                 // received. Send all coalesced
+                                                 // packets to both addresses.
 
 // Optional support of truncated Connection IDs.  If sent by a peer, the value
 // is the minimum number of bytes allowed for the connection ID sent to the
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index 091618b..f3b7f03 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -5511,6 +5511,45 @@
   EXPECT_TRUE(client_stats.failed_to_validate_server_preferred_address);
 }
 
+TEST_P(EndToEndTest, OptimizedServerPreferredAddress) {
+  ASSERT_TRUE(Initialize());
+  if (!GetClientConnection()->connection_migration_use_new_cid()) {
+    return;
+  }
+  client_->Disconnect();
+  StopServer();
+  // server_address_ now contains the random listening port.
+  const QuicSocketAddress kServerPreferredAddress =
+      QuicSocketAddress(TestLoopback(2), server_address_.port());
+  ASSERT_NE(server_address_, kServerPreferredAddress);
+  // Send server preferred address and let server listen on Any.
+  if (kServerPreferredAddress.host().IsIPv4()) {
+    server_listening_address_ =
+        QuicSocketAddress(QuicIpAddress::Any4(), server_address_.port());
+    server_config_.SetIPv4AlternateServerAddressToSend(kServerPreferredAddress);
+  } else {
+    server_listening_address_ =
+        QuicSocketAddress(QuicIpAddress::Any6(), server_address_.port());
+    server_config_.SetIPv6AlternateServerAddressToSend(kServerPreferredAddress);
+  }
+  // Server restarts.
+  server_writer_ = new PacketDroppingTestWriter();
+  StartServer();
+
+  client_config_.SetConnectionOptionsToSend(QuicTagVector{kRVCM});
+  client_config_.SetClientConnectionOptions(QuicTagVector{kSPAD, kSPA2});
+  client_.reset(CreateQuicClient(nullptr));
+  EXPECT_TRUE(client_->client()->WaitForHandshakeConfirmed());
+  while (client_->client()->HasPendingPathValidation()) {
+    client_->client()->WaitForEvents();
+  }
+  // TODO(b/262386897): Currently, server drops packets received on preferred
+  // address because self address change is disallowed.
+  const auto client_stats = GetClientConnection()->GetStats();
+  EXPECT_FALSE(client_stats.server_preferred_address_validated);
+  EXPECT_TRUE(client_stats.failed_to_validate_server_preferred_address);
+}
+
 TEST_P(EndToEndPacketReorderingTest, ReorderedPathChallenge) {
   ASSERT_TRUE(Initialize());
   if (!version_.HasIetfQuicFrames()) {
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 2f5f56f..a929e3a 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -706,10 +706,15 @@
                config.HasReceivedIPv6AlternateServerAddress()) {
       server_preferred_address_ = config.ReceivedIPv6AlternateServerAddress();
     }
-    QUIC_DLOG_IF(INFO, server_preferred_address_.IsInitialized())
-        << ENDPOINT
-        << "Received server preferred address: " << server_preferred_address_;
     AddKnownServerAddress(server_preferred_address_);
+    if (server_preferred_address_.IsInitialized()) {
+      QUICHE_DLOG(INFO) << ENDPOINT << "Received server preferred address: "
+                        << server_preferred_address_;
+      if (config.HasClientRequestedIndependentOption(kSPA2, perspective_)) {
+        accelerated_server_preferred_address_ = true;
+        ValidateServerPreferredAddress();
+      }
+    }
   }
   if (config.HasReceivedMaxPacketSize()) {
     peer_max_packet_size_ = config.ReceivedMaxPacketSize();
@@ -3997,20 +4002,10 @@
   // Re-arm ack alarm.
   ack_alarm_->Update(uber_received_packet_manager_.GetEarliestAckTimeout(),
                      kAlarmGranularity);
-  if (server_preferred_address_.IsInitialized()) {
+  if (!accelerated_server_preferred_address_ &&
+      server_preferred_address_.IsInitialized()) {
     QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
-    // Validate received server preferred address.
-    auto context =
-        visitor_->CreatePathValidationContextForServerPreferredAddress(
-            server_preferred_address_);
-    if (context != nullptr) {
-      QUICHE_DLOG(INFO) << ENDPOINT
-                        << "Start validating server preferred address: "
-                        << server_preferred_address_;
-      auto result_delegate =
-          std::make_unique<ServerPreferredAddressResultDelegate>(this);
-      ValidatePath(std::move(context), std::move(result_delegate));
-    }
+    ValidateServerPreferredAddress();
   }
 }
 
@@ -5924,6 +5919,16 @@
       }
     }
   }
+  if (accelerated_server_preferred_address_ &&
+      stats_.num_duplicated_packets_sent_to_server_preferred_address <
+          kMaxDuplicatedPacketsSentToServerPreferredAddress) {
+    // Send coalesced packets to both addresses while the server preferred
+    // address validation is pending.
+    QUICHE_DCHECK(server_preferred_address_.IsInitialized());
+    path_validator_.MaybeWritePacketToAddress(buffer, length,
+                                              server_preferred_address_);
+    ++stats_.num_duplicated_packets_sent_to_server_preferred_address;
+  }
   // Account for added padding.
   if (length > coalesced_packet_.length()) {
     if (IsDefaultPath(coalesced_packet_.self_address(),
@@ -6423,6 +6428,21 @@
       ->MaybeIssueNewConnectionIdForPreferredAddress();
 }
 
+void QuicConnection::ValidateServerPreferredAddress() {
+  QUICHE_DCHECK(server_preferred_address_.IsInitialized());
+  // Validate received server preferred address.
+  auto context = visitor_->CreatePathValidationContextForServerPreferredAddress(
+      server_preferred_address_);
+  if (context == nullptr) {
+    return;
+  }
+  QUICHE_DLOG(INFO) << ENDPOINT << "Start validating server preferred address: "
+                    << server_preferred_address_;
+  auto result_delegate =
+      std::make_unique<ServerPreferredAddressResultDelegate>(this);
+  ValidatePath(std::move(context), std::move(result_delegate));
+}
+
 bool QuicConnection::ShouldDetectBlackhole() const {
   if (!connected_ || blackhole_detection_disabled_) {
     return false;
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index cc22c19..ca25805 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -1272,6 +1272,9 @@
   absl::optional<QuicNewConnectionIdFrame>
   MaybeIssueNewConnectionIdForPreferredAddress();
 
+  // Kicks off validation of received server preferred address.
+  void ValidateServerPreferredAddress();
+
  protected:
   // Calls cancel() on all the alarms owned by this connection.
   void CancelAllAlarms();
@@ -2282,6 +2285,11 @@
   // only.
   QuicSocketAddress server_preferred_address_;
 
+  // If true, kicks off validation of server_preferred_address_ once it is
+  // received. Also, send all coalesced packets on both paths until handshake is
+  // confirmed.
+  bool accelerated_server_preferred_address_ = false;
+
   // If true, throttle sending if next created packet will exceed amplification
   // limit.
   const bool enforce_strict_amplification_factor_ =
diff --git a/quiche/quic/core/quic_connection_stats.cc b/quiche/quic/core/quic_connection_stats.cc
index 0321498..fd74285 100644
--- a/quiche/quic/core/quic_connection_stats.cc
+++ b/quiche/quic/core/quic_connection_stats.cc
@@ -67,6 +67,8 @@
      << s.server_preferred_address_validated;
   os << " failed_to_validate_server_preferred_address: "
      << s.failed_to_validate_server_preferred_address;
+  os << " num_duplicated_packets_sent_to_server_preferred_address: "
+     << s.num_duplicated_packets_sent_to_server_preferred_address;
   os << " }";
 
   return os;
diff --git a/quiche/quic/core/quic_connection_stats.h b/quiche/quic/core/quic_connection_stats.h
index 94acd93..82b0255 100644
--- a/quiche/quic/core/quic_connection_stats.h
+++ b/quiche/quic/core/quic_connection_stats.h
@@ -220,6 +220,9 @@
 
   bool server_preferred_address_validated = false;
   bool failed_to_validate_server_preferred_address = false;
+  // Number of duplicated packets that have been sent to server preferred
+  // address while the validation is pending.
+  size_t num_duplicated_packets_sent_to_server_preferred_address = 0;
 
   struct QUIC_NO_EXPORT TlsServerOperationStats {
     bool success = false;
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 314f491..874eeb1 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -1463,7 +1463,7 @@
   }
 
   // Receive server preferred address.
-  void ServerPreferredAddressInit() {
+  void ServerPreferredAddressInit(QuicConfig& config) {
     ASSERT_EQ(Perspective::IS_CLIENT, connection_.perspective());
     ASSERT_TRUE(version().HasIetfQuicFrames());
     ASSERT_TRUE(connection_.self_address().host().IsIPv6());
@@ -1485,10 +1485,9 @@
     ProcessFramePacketAtLevel(1, QuicFrame(&frame), ENCRYPTION_INITIAL);
     // Discard INITIAL key.
     connection_.RemoveEncrypter(ENCRYPTION_INITIAL);
+    connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
 
-    QuicConfig config;
     config.SetConnectionOptionsToSend(QuicTagVector{kRVCM});
-    config.SetClientConnectionOptions(QuicTagVector{kSPAD});
     QuicConfigPeer::SetReceivedStatelessResetToken(&config,
                                                    kTestStatelessResetToken);
     QuicConfigPeer::SetReceivedAlternateServerAddress(&config,
@@ -15987,7 +15986,9 @@
   if (!connection_.version().HasIetfQuicFrames()) {
     return;
   }
-  ServerPreferredAddressInit();
+  QuicConfig config;
+  config.SetClientConnectionOptions(QuicTagVector{kSPAD});
+  ServerPreferredAddressInit(config);
   const QuicSocketAddress kServerPreferredAddress =
       QuicConnectionPeer::GetServerPreferredAddress(&connection_);
   const QuicSocketAddress kNewSelfAddress =
@@ -16065,7 +16066,9 @@
   if (!connection_.version().HasIetfQuicFrames()) {
     return;
   }
-  ServerPreferredAddressInit();
+  QuicConfig config;
+  config.SetClientConnectionOptions(QuicTagVector{kSPAD});
+  ServerPreferredAddressInit(config);
   const QuicSocketAddress kServerPreferredAddress =
       QuicConnectionPeer::GetServerPreferredAddress(&connection_);
   const QuicSocketAddress kNewSelfAddress =
@@ -16129,7 +16132,9 @@
   if (!connection_.version().HasIetfQuicFrames()) {
     return;
   }
-  ServerPreferredAddressInit();
+  QuicConfig config;
+  config.SetClientConnectionOptions(QuicTagVector{kSPAD});
+  ServerPreferredAddressInit(config);
   const QuicSocketAddress kServerPreferredAddress =
       QuicConnectionPeer::GetServerPreferredAddress(&connection_);
   const QuicSocketAddress kNewSelfAddress =
@@ -16191,6 +16196,128 @@
       connection_.GetStats().failed_to_validate_server_preferred_address);
 }
 
+TEST_P(QuicConnectionTest, OptimizedServerPreferredAddress) {
+  if (!connection_.version().HasIetfQuicFrames()) {
+    return;
+  }
+  QuicIpAddress host;
+  host.FromString("2604:31c0::");
+  const QuicSocketAddress kServerPreferredAddress(host, 443);
+  const QuicSocketAddress kNewSelfAddress =
+      QuicSocketAddress(QuicIpAddress::Loopback6(), /*port=*/23456);
+  TestPacketWriter new_writer(version(), &clock_, Perspective::IS_CLIENT);
+  EXPECT_CALL(visitor_, CreatePathValidationContextForServerPreferredAddress(
+                            kServerPreferredAddress))
+      .WillOnce(Return(
+          testing::ByMove(std::make_unique<TestQuicPathValidationContext>(
+              kNewSelfAddress, kServerPreferredAddress, &new_writer))));
+  QuicConfig config;
+  config.SetClientConnectionOptions(QuicTagVector{kSPAD, kSPA2});
+  ServerPreferredAddressInit(config);
+  EXPECT_TRUE(connection_.HasPendingPathValidation());
+  ASSERT_FALSE(new_writer.path_challenge_frames().empty());
+
+  // Send data packet while path validation is pending.
+  connection_.SendStreamDataWithString(3, "foo", 0, NO_FIN);
+  // Verify the packet is sent on both paths.
+  EXPECT_FALSE(writer_->stream_frames().empty());
+  EXPECT_FALSE(new_writer.stream_frames().empty());
+
+  // Verify packet duplication stops on handshake confirmed.
+  EXPECT_CALL(visitor_, GetHandshakeState())
+      .WillRepeatedly(Return(HANDSHAKE_CONFIRMED));
+  connection_.OnHandshakeComplete();
+  SendPing();
+  EXPECT_FALSE(writer_->ping_frames().empty());
+  EXPECT_TRUE(new_writer.ping_frames().empty());
+}
+
+TEST_P(QuicConnectionTest, OptimizedServerPreferredAddress2) {
+  if (!connection_.version().HasIetfQuicFrames()) {
+    return;
+  }
+  QuicIpAddress host;
+  host.FromString("2604:31c0::");
+  const QuicSocketAddress kServerPreferredAddress(host, 443);
+  const QuicSocketAddress kNewSelfAddress =
+      QuicSocketAddress(QuicIpAddress::Loopback6(), /*port=*/23456);
+  TestPacketWriter new_writer(version(), &clock_, Perspective::IS_CLIENT);
+  EXPECT_CALL(visitor_, CreatePathValidationContextForServerPreferredAddress(
+                            kServerPreferredAddress))
+      .WillOnce(Return(
+          testing::ByMove(std::make_unique<TestQuicPathValidationContext>(
+              kNewSelfAddress, kServerPreferredAddress, &new_writer))));
+  QuicConfig config;
+  config.SetClientConnectionOptions(QuicTagVector{kSPAD, kSPA2});
+  ServerPreferredAddressInit(config);
+  EXPECT_TRUE(connection_.HasPendingPathValidation());
+  ASSERT_FALSE(new_writer.path_challenge_frames().empty());
+
+  // Send data packet while path validation is pending.
+  connection_.SendStreamDataWithString(3, "foo", 0, NO_FIN);
+  // Verify the packet is sent on both paths.
+  EXPECT_FALSE(writer_->stream_frames().empty());
+  EXPECT_FALSE(new_writer.stream_frames().empty());
+
+  // Simluate path validation times out.
+  for (size_t i = 0; i < QuicPathValidator::kMaxRetryTimes + 1; ++i) {
+    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(3 * kInitialRttMs));
+    static_cast<TestAlarmFactory::TestAlarm*>(
+        QuicPathValidatorPeer::retry_timer(
+            QuicConnectionPeer::path_validator(&connection_)))
+        ->Fire();
+  }
+  EXPECT_FALSE(connection_.HasPendingPathValidation());
+  // Verify packet duplication stops if there is no pending validation.
+  SendPing();
+  EXPECT_FALSE(writer_->ping_frames().empty());
+  EXPECT_TRUE(new_writer.ping_frames().empty());
+}
+
+TEST_P(QuicConnectionTest, MaxDuplicatedPacketsSentToServerPreferredAddress) {
+  if (!connection_.version().HasIetfQuicFrames()) {
+    return;
+  }
+  QuicIpAddress host;
+  host.FromString("2604:31c0::");
+  const QuicSocketAddress kServerPreferredAddress(host, 443);
+  const QuicSocketAddress kNewSelfAddress =
+      QuicSocketAddress(QuicIpAddress::Loopback6(), /*port=*/23456);
+  TestPacketWriter new_writer(version(), &clock_, Perspective::IS_CLIENT);
+  EXPECT_CALL(visitor_, CreatePathValidationContextForServerPreferredAddress(
+                            kServerPreferredAddress))
+      .WillOnce(Return(
+          testing::ByMove(std::make_unique<TestQuicPathValidationContext>(
+              kNewSelfAddress, kServerPreferredAddress, &new_writer))));
+  QuicConfig config;
+  config.SetClientConnectionOptions(QuicTagVector{kSPAD, kSPA2});
+  ServerPreferredAddressInit(config);
+  EXPECT_TRUE(connection_.HasPendingPathValidation());
+  ASSERT_FALSE(new_writer.path_challenge_frames().empty());
+
+  // Send data packet while path validation is pending.
+  size_t write_limit = writer_->packets_write_attempts();
+  size_t new_write_limit = new_writer.packets_write_attempts();
+  for (size_t i = 0; i < kMaxDuplicatedPacketsSentToServerPreferredAddress;
+       ++i) {
+    connection_.SendStreamDataWithString(3, "foo", i * 3, NO_FIN);
+    // Verify the packet is sent on both paths.
+    ASSERT_EQ(write_limit + 1, writer_->packets_write_attempts());
+    ASSERT_EQ(new_write_limit + 1, new_writer.packets_write_attempts());
+    ++write_limit;
+    ++new_write_limit;
+    EXPECT_FALSE(writer_->stream_frames().empty());
+    EXPECT_FALSE(new_writer.stream_frames().empty());
+  }
+
+  // Verify packet duplication stops if duplication limit is hit.
+  SendPing();
+  ASSERT_EQ(write_limit + 1, writer_->packets_write_attempts());
+  ASSERT_EQ(new_write_limit, new_writer.packets_write_attempts());
+  EXPECT_FALSE(writer_->ping_frames().empty());
+  EXPECT_TRUE(new_writer.ping_frames().empty());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quiche/quic/core/quic_constants.h b/quiche/quic/core/quic_constants.h
index 4589189..dfd908e 100644
--- a/quiche/quic/core/quic_constants.h
+++ b/quiche/quic/core/quic_constants.h
@@ -326,6 +326,8 @@
 
 inline constexpr size_t kMaxNumMultiPortPaths = 5;
 
+inline constexpr size_t kMaxDuplicatedPacketsSentToServerPreferredAddress = 5;
+
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_CORE_QUIC_CONSTANTS_H_
diff --git a/quiche/quic/core/quic_path_validator.cc b/quiche/quic/core/quic_path_validator.cc
index 61e3dad..6179fe5 100644
--- a/quiche/quic/core/quic_path_validator.cc
+++ b/quiche/quic/core/quic_path_validator.cc
@@ -149,4 +149,18 @@
          path_context_->effective_peer_address() == effective_peer_address;
 }
 
+void QuicPathValidator::MaybeWritePacketToAddress(
+    const char* buffer, size_t buf_len, const QuicSocketAddress& peer_address) {
+  if (!HasPendingPathValidation() ||
+      path_context_->peer_address() != peer_address) {
+    return;
+  }
+  QUIC_DVLOG(1) << "Path validator is sending packet of size " << buf_len
+                << " from " << path_context_->self_address() << " to "
+                << path_context_->peer_address();
+  path_context_->WriterToUse()->WritePacket(
+      buffer, buf_len, path_context_->self_address().host(),
+      path_context_->peer_address(), nullptr);
+}
+
 }  // namespace quic
diff --git a/quiche/quic/core/quic_path_validator.h b/quiche/quic/core/quic_path_validator.h
index 4389ce5..4b94892 100644
--- a/quiche/quic/core/quic_path_validator.h
+++ b/quiche/quic/core/quic_path_validator.h
@@ -138,6 +138,11 @@
 
   bool IsValidatingPeerAddress(const QuicSocketAddress& effective_peer_address);
 
+  // Called to send packet to |peer_address| if the path validation to this
+  // address is pending.
+  void MaybeWritePacketToAddress(const char* buffer, size_t buf_len,
+                                 const QuicSocketAddress& peer_address);
+
  private:
   friend class test::QuicPathValidatorPeer;