diff --git a/packages/bridge-controller/src/utils/validators.ts b/packages/bridge-controller/src/utils/validators.ts
index 73603b2ee9b..23af0709247 100644
--- a/packages/bridge-controller/src/utils/validators.ts
+++ b/packages/bridge-controller/src/utils/validators.ts
@@ -468,6 +468,7 @@ export const QuoteResponseSchema = type({
     TronTradeDataSchema,
     string(),
   ]),
+  quoteId: string(),
 });
 
 export const validateQuoteResponse = (
diff --git a/packages/bridge-status-controller/src/bridge-status-controller.ts b/packages/bridge-status-controller/src/bridge-status-controller.ts
index 208cfe7f98e..e287737a2c0 100644
--- a/packages/bridge-status-controller/src/bridge-status-controller.ts
+++ b/packages/bridge-status-controller/src/bridge-status-controller.ts
@@ -41,6 +41,7 @@ import {
   MAX_ATTEMPTS,
   REFRESH_INTERVAL_MS,
 } from './constants';
+import { QuoteStatusUpdateManager } from './quote-status-update-manager';
 import type {
   BridgeStatusControllerState,
   StartPollingForBridgeTxStatusArgsSerialized,
@@ -109,6 +110,12 @@ const metadata: StateMetadata<BridgeStatusControllerState> = {
     includeInDebugSnapshot: false,
     usedInUi: true,
   },
+  deferredStatusUpdates: {
+    includeInStateLogs: false,
+    persist: true,
+    includeInDebugSnapshot: false,
+    usedInUi: false,
+  },
 };
 
 /** The input to start polling for the {@link BridgeStatusController} */
@@ -138,6 +145,8 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
 
   readonly #intentManager: IntentManager;
 
+  readonly #quoteStatusUpdateManager: QuoteStatusUpdateManager;
+
   readonly #clientId: BridgeClientId;
 
   readonly #fetchFn: FetchFunction;
@@ -193,6 +202,18 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
       customBridgeApiBaseUrl: this.#config.customBridgeApiBaseUrl,
       fetchFn: this.#fetchFn,
     });
+    this.#quoteStatusUpdateManager = new QuoteStatusUpdateManager({
+      messenger: this.messenger,
+      fetchFn: this.#fetchFn,
+      clientId: this.#clientId,
+      apiBaseUrl: this.#config.customBridgeApiBaseUrl,
+      initialDeferredUpdates: this.state.deferredStatusUpdates,
+      persistDeferredUpdates: (updates): void => {
+        this.update((draft) => {
+          draft.deferredStatusUpdates = updates;
+        });
+      },
+    });
 
     // Register action handlers
     this.messenger.registerMethodActionHandlers(
@@ -224,6 +245,8 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
         ) {
           // Mark tx as failed in txHistory
           this.#markTxAsFailed(transactionMeta);
+          console.log('1 wefwewef - finalized failed', txMetaId);
+          this.#quoteStatusUpdateManager.reportFinalised(txMetaId, false);
           // Track failed event
           if (status !== TransactionStatus.rejected) {
             // Look up history by txMetaId first, then by actionId (for pre-submission failures)
@@ -257,6 +280,39 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
         if (type === TransactionType.bridge && !isNonEvmChainId(chainId)) {
           this.#startPollingForTxId(txMetaId);
         }
+        if (
+          type &&
+          [TransactionType.bridge, TransactionType.swap].includes(type)
+        ) {
+          console.log('2 wefwewef - finalized success', txMetaId);
+          this.#quoteStatusUpdateManager.reportFinalised(txMetaId, true);
+        }
+      },
+    );
+
+    // For batch EVM transactions (STX / gasIncluded7702) the tx hash is not
+    // available when submitTx returns, so we report the submitted status here
+    // once the TransactionController has broadcast the tx and assigned a hash.
+    this.messenger.subscribe(
+      'TransactionController:transactionSubmitted',
+      ({ transactionMeta }) => {
+        const { type, id: txMetaId, hash } = transactionMeta;
+        if (
+          hash &&
+          type &&
+          [TransactionType.bridge, TransactionType.swap].includes(type)
+        ) {
+          const historyItem = this.state.txHistory[txMetaId];
+          const requestId = historyItem?.quote?.requestId;
+          if (requestId) {
+            console.log('3 wefwewef - submitted', requestId, hash, txMetaId);
+            this.#quoteStatusUpdateManager.reportSubmitted(
+              requestId,
+              hash,
+              txMetaId,
+            );
+          }
+        }
       },
     );
 
@@ -296,8 +352,11 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
   };
 
   resetState = (): void => {
+    this.#quoteStatusUpdateManager.destroy();
     this.update((state) => {
       state.txHistory = DEFAULT_BRIDGE_STATUS_CONTROLLER_STATE.txHistory;
+      state.deferredStatusUpdates =
+        DEFAULT_BRIDGE_STATUS_CONTROLLER_STATE.deferredStatusUpdates;
     });
   };
 
@@ -584,6 +643,10 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
       this.stopPollingByPollingToken(pollingToken);
       delete this.#pollingTokensByTxMetaId[bridgeTxMetaId];
 
+      // Finalize the quote status update as a failure since we can no longer
+      // determine the outcome via polling.
+      this.#quoteStatusUpdateManager.reportFinalised(bridgeTxMetaId, false);
+
       // Track max polling reached event
       const historyItem = this.state.txHistory[bridgeTxMetaId];
       if (historyItem && !historyItem.featureId) {
@@ -740,9 +803,16 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
         status.status === StatusTypes.COMPLETE ||
         status.status === StatusTypes.FAILED;
 
-      if (isFinalStatus && pollingToken) {
-        this.stopPollingByPollingToken(pollingToken);
-        delete this.#pollingTokensByTxMetaId[bridgeTxMetaId];
+      if (isFinalStatus) {
+        if (pollingToken) {
+          this.stopPollingByPollingToken(pollingToken);
+          delete this.#pollingTokensByTxMetaId[bridgeTxMetaId];
+        }
+
+        this.#quoteStatusUpdateManager.reportFinalised(
+          bridgeTxMetaId,
+          status.status === StatusTypes.COMPLETE,
+        );
 
         // Skip tracking events when featureId is set (i.e. PERPS)
         if (historyItem.featureId) {
@@ -1171,6 +1241,25 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
         !quoteResponse.quote.gasIncluded7702 &&
         !isDelegatedAccount;
 
+      console.log('wefwefwe', JSON.stringify(txMeta, null, 2));
+      // Report submitted status to the Bridge API.
+      // For non-batch EVM and non-EVM, the hash is available now.
+      // For batch EVM (STX/gasIncluded7702), the hash arrives later via the
+      // TransactionController:transactionSubmitted event subscriber.
+      if (txMeta.hash) {
+        console.log(
+          '5 wefwewef - submitted',
+          quoteResponse.quoteId,
+          txMeta.hash,
+          txMeta.id,
+        );
+        this.#quoteStatusUpdateManager.reportSubmitted(
+          quoteResponse.quoteId,
+          txMeta.hash,
+          txMeta.id,
+        );
+      }
+
       if (!isNonBatchEvm) {
         // Add swap or bridge tx to history
         this.#addTxToHistory({
@@ -1190,8 +1279,16 @@ export class BridgeStatusController extends StaticIntervalPollingController<Brid
       if (isNonEvmChainId(quoteResponse.quote.srcChainId)) {
         // Start polling for bridge tx status
         this.#startPollingForTxId(txMeta.id);
-        // Track non-EVM Swap completed event
+        // Non-EVM swaps (same-chain) are considered finalized immediately
+        console.log(
+          'uh3r2ehi2eh ',
+          isBridgeTx,
+          isTronTx,
+          !(isBridgeTx || isTronTx),
+        );
         if (!(isBridgeTx || isTronTx)) {
+          console.log('6 wefwewef - finalized sucess', txMeta.id);
+          this.#quoteStatusUpdateManager.reportFinalised(txMeta.id, true);
           this.#trackUnifiedSwapBridgeEvent(
             UnifiedSwapBridgeEventName.Completed,
             txMeta.id,
diff --git a/packages/bridge-status-controller/src/constants.ts b/packages/bridge-status-controller/src/constants.ts
index ba9251f1e33..c65e32d3001 100644
--- a/packages/bridge-status-controller/src/constants.ts
+++ b/packages/bridge-status-controller/src/constants.ts
@@ -8,8 +8,18 @@ export const BRIDGE_STATUS_CONTROLLER_NAME = 'BridgeStatusController';
 export const DEFAULT_BRIDGE_STATUS_CONTROLLER_STATE: BridgeStatusControllerState =
   {
     txHistory: {},
+    deferredStatusUpdates: {},
   };
 
+export const QUOTE_STATUS_UPDATE_RETRY_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+export const QUOTE_STATUS_UPDATE_RETRY_MAX_LIFETIME_MS = 12 * 60 * 60 * 1000; // 12 hours
+
+export enum QuoteStatusUpdateType {
+  Submitted = 'SUBMITTED',
+  FinalizedSuccess = 'FINALIZED_SUCCESS',
+  FinalizedFailure = 'FINALIZED_FAILURE',
+}
+
 export const BRIDGE_PROD_API_BASE_URL = 'https://bridge.api.cx.metamask.io';
 
 export const APPROVAL_DELAY_MS = 5000;
diff --git a/packages/bridge-status-controller/src/index.ts b/packages/bridge-status-controller/src/index.ts
index c2eb5c432d5..9f0d2ddafc3 100644
--- a/packages/bridge-status-controller/src/index.ts
+++ b/packages/bridge-status-controller/src/index.ts
@@ -15,6 +15,7 @@ export type {
   RefuelStatusResponse,
   BridgeHistoryItem,
   BridgeStatusControllerState,
+  DeferredStatusUpdateEntry,
   BridgeStatusControllerMessenger,
   BridgeStatusControllerActions,
   BridgeStatusControllerGetStateAction,
diff --git a/packages/bridge-status-controller/src/quote-status-update-manager.ts b/packages/bridge-status-controller/src/quote-status-update-manager.ts
new file mode 100644
index 00000000000..eef16b99d32
--- /dev/null
+++ b/packages/bridge-status-controller/src/quote-status-update-manager.ts
@@ -0,0 +1,349 @@
+import type { BridgeClientId } from '@metamask/bridge-controller';
+import { getClientHeaders } from '@metamask/bridge-controller';
+import {
+  HttpError,
+  createServicePolicy,
+  ConstantBackoff,
+} from '@metamask/controller-utils';
+
+import {
+  QUOTE_STATUS_UPDATE_RETRY_INTERVAL_MS,
+  QUOTE_STATUS_UPDATE_RETRY_MAX_LIFETIME_MS,
+  QuoteStatusUpdateType,
+} from './constants';
+import type {
+  BridgeStatusControllerMessenger,
+  DeferredStatusUpdateEntry,
+  FetchFunction,
+} from './types';
+import { getJwt } from './utils/authentication';
+
+/**
+ * Handles reporting quote status updates (SUBMITTED / FINALISED) to the
+ * Bridge API via a single persisted deferred retry queue.
+ *
+ * Each entry holds a FIFO queue of status strings (`pendingStatuses`) to
+ * send in order. {@link reportSubmitted} creates an entry with `SUBMITTED`
+ * as the first pending status. {@link reportFinalised} appends the final
+ * outcome (`FINALIZED_SUCCESS` or `FINALIZED_FAILURE`). Processing sends
+ * `pendingStatuses[0]`, and on success shifts it off. The entry is deleted
+ * once the queue is empty.
+ *
+ * Entries are retried every {@link QUOTE_STATUS_UPDATE_RETRY_INTERVAL_MS}
+ * for up to {@link QUOTE_STATUS_UPDATE_RETRY_MAX_LIFETIME_MS}.
+ */
+export class QuoteStatusUpdateManager {
+  readonly #messenger: BridgeStatusControllerMessenger;
+
+  readonly #fetchFn: FetchFunction;
+
+  readonly #clientId: BridgeClientId;
+
+  readonly #apiBaseUrl: string;
+
+  readonly #deferredRetryQueue: Map<string, DeferredStatusUpdateEntry>;
+
+  readonly #persistDeferredUpdates: (
+    updates: Record<string, DeferredStatusUpdateEntry>,
+  ) => void;
+
+  /**
+   * Tracks which keys have an in-flight #processSingleEntry call to prevent
+   * concurrent processing of the same entry.
+   */
+  readonly #inFlight = new Set<string>();
+
+  #retryIntervalId: ReturnType<typeof setInterval> | null = null;
+
+  constructor({
+    messenger,
+    fetchFn,
+    clientId,
+    apiBaseUrl,
+    initialDeferredUpdates,
+    persistDeferredUpdates,
+  }: {
+    messenger: BridgeStatusControllerMessenger;
+    fetchFn: FetchFunction;
+    clientId: BridgeClientId;
+    apiBaseUrl: string;
+    initialDeferredUpdates?: Record<string, DeferredStatusUpdateEntry>;
+    persistDeferredUpdates: (
+      updates: Record<string, DeferredStatusUpdateEntry>,
+    ) => void;
+  }) {
+    this.#messenger = messenger;
+    this.#fetchFn = fetchFn;
+    this.#clientId = clientId;
+    this.#apiBaseUrl = apiBaseUrl;
+    this.#persistDeferredUpdates = persistDeferredUpdates;
+
+    this.#deferredRetryQueue = new Map(
+      Object.entries(initialDeferredUpdates ?? {}),
+    );
+
+    this.#dropExpiredEntries();
+
+    // If there are items to be processed, start the poller and
+    // immediately attempt to process all entries (don't wait for
+    // the first interval tick).
+    if (this.#deferredRetryQueue.size > 0) {
+      this.#ensureRetryTimerRunning();
+      let delay = 0;
+      for (const key of this.#deferredRetryQueue.keys()) {
+        setTimeout(() => this.#processSingleEntry(key), delay);
+        delay += 125;
+      }
+    }
+  }
+
+  /**
+   * Enqueues a SUBMITTED status report and immediately attempts to send it.
+   *
+   * @param quoteId - The quote id
+   * @param srcTxHash - The source transaction hash
+   * @param txMetaId - Optional transaction meta id for finalization tracking
+   */
+  reportSubmitted(quoteId: string, srcTxHash: string, txMetaId?: string): void {
+    const key = this.#enqueue({
+      quoteId,
+      srcTxHash,
+      txMetaId,
+      pendingStatuses: [QuoteStatusUpdateType.Submitted],
+    });
+    this.#processSingleEntry(key);
+  }
+
+  /**
+   * Appends the final outcome to the entry's pending statuses queue.
+   *
+   * If the entry is not currently in-flight, triggers processing
+   * immediately. Otherwise the outcome will be picked up once the
+   * current in-flight call completes and the retry loop continues.
+   *
+   * @param txMetaId - The transaction meta id
+   * @param success - Whether the transaction succeeded
+   */
+  reportFinalised(txMetaId: string, success: boolean): void {
+    const matchingKey = this.#findKeyByTxMetaId(txMetaId);
+    if (!matchingKey) {
+      return;
+    }
+
+    const entry = this.#deferredRetryQueue.get(
+      matchingKey,
+    ) as DeferredStatusUpdateEntry;
+
+    entry.pendingStatuses.push(
+      success
+        ? QuoteStatusUpdateType.FinalizedSuccess
+        : QuoteStatusUpdateType.FinalizedFailure,
+    );
+    this.#persistToState();
+
+    if (!this.#inFlight.has(matchingKey)) {
+      this.#processSingleEntry(matchingKey);
+    }
+  }
+
+  /**
+   * Stops the deferred retry timer and clears the in-memory queue.
+   * Does not persist — the caller is responsible for resetting state.
+   */
+  destroy(): void {
+    this.#stopRetryTimer();
+    this.#deferredRetryQueue.clear();
+    this.#inFlight.clear();
+  }
+
+  #enqueue(
+    entry: Omit<DeferredStatusUpdateEntry, 'createdAt' | 'lastAttemptAt'>,
+  ): string {
+    const key = `${entry.quoteId}:${entry.srcTxHash}`;
+    const now = Date.now();
+    this.#deferredRetryQueue.set(key, {
+      ...entry,
+      createdAt: now,
+      lastAttemptAt: now,
+    });
+    this.#persistToState();
+    this.#ensureRetryTimerRunning();
+    return key;
+  }
+
+  #findKeyByTxMetaId(txMetaId: string): string | undefined {
+    for (const [key, entry] of this.#deferredRetryQueue) {
+      if (entry.txMetaId === txMetaId) {
+        return key;
+      }
+    }
+    return undefined;
+  }
+
+  #processSingleEntry(key: string): void {
+    const entry = this.#deferredRetryQueue.get(key);
+    if (!entry || this.#inFlight.has(key)) {
+      return;
+    }
+
+    if (entry.pendingStatuses.length === 0) {
+      this.#removeEntry(key);
+      return;
+    }
+
+    if (
+      Date.now() - entry.createdAt >
+      QUOTE_STATUS_UPDATE_RETRY_MAX_LIFETIME_MS
+    ) {
+      console.error(
+        `QuoteStatusUpdateManager: evicting deferred retry for quote ${entry.quoteId} — exceeded 12-hour retry window`,
+      );
+      this.#removeEntry(key);
+      return;
+    }
+
+    this.#inFlight.add(key);
+
+    this.#sendWithRetry(
+      entry.quoteId,
+      entry.srcTxHash,
+      entry.pendingStatuses[0],
+    )
+      .then(() => {
+        entry.pendingStatuses.shift();
+
+        if (entry.pendingStatuses.length > 0) {
+          this.#persistToState();
+          this.#inFlight.delete(key);
+          this.#processSingleEntry(key);
+        } else {
+          this.#inFlight.delete(key);
+          this.#removeEntry(key);
+        }
+        return undefined;
+      })
+      .catch((error: unknown) => {
+        this.#inFlight.delete(key);
+
+        if (error instanceof HttpError && error.httpStatus === 400) {
+          if (entry.txMetaId) {
+            entry.pendingStatuses.shift();
+          } else {
+            this.#removeEntry(key);
+            console.error(
+              `QuoteStatusUpdateManager: HTTP 400 for quote ${entry.quoteId} with no txMetaId — evicting`,
+            );
+            return;
+          }
+        }
+
+        entry.lastAttemptAt = Date.now();
+        this.#persistToState();
+      });
+  }
+
+  async #sendWithRetry(
+    quoteId: string,
+    srcTxHash: string,
+    status: string,
+  ): Promise<void> {
+    const policy = createServicePolicy({
+      maxRetries: 6,
+      backoff: new ConstantBackoff(5_000),
+    });
+    await policy.execute(() =>
+      this.#updateQuoteStatus(quoteId, srcTxHash, status),
+    );
+  }
+
+  #removeEntry(key: string): void {
+    this.#deferredRetryQueue.delete(key);
+    this.#persistToState();
+    if (this.#deferredRetryQueue.size === 0) {
+      this.#stopRetryTimer();
+    }
+  }
+
+  #ensureRetryTimerRunning(): void {
+    if (this.#retryIntervalId !== null) {
+      return;
+    }
+    this.#retryIntervalId = setInterval(
+      () => this.#processDeferredRetries(),
+      QUOTE_STATUS_UPDATE_RETRY_INTERVAL_MS,
+    );
+  }
+
+  #stopRetryTimer(): void {
+    if (this.#retryIntervalId !== null) {
+      clearInterval(this.#retryIntervalId);
+      this.#retryIntervalId = null;
+    }
+  }
+
+  #processDeferredRetries(): void {
+    this.#dropExpiredEntries();
+
+    if (this.#deferredRetryQueue.size === 0) {
+      this.#stopRetryTimer();
+      return;
+    }
+
+    for (const key of this.#deferredRetryQueue.keys()) {
+      this.#processSingleEntry(key);
+    }
+  }
+
+  #dropExpiredEntries(): void {
+    const now = Date.now();
+    let changed = false;
+
+    for (const [key, entry] of this.#deferredRetryQueue) {
+      if (now - entry.createdAt > QUOTE_STATUS_UPDATE_RETRY_MAX_LIFETIME_MS) {
+        this.#deferredRetryQueue.delete(key);
+        console.error(
+          `QuoteStatusUpdateManager: evicting deferred retry for quote ${entry.quoteId} — exceeded 12-hour retry window`,
+        );
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      this.#persistToState();
+    }
+  }
+
+  /**
+   * Clones entries before persisting so the controller's state management
+   * (Immer) does not freeze the in-memory Map objects.
+   */
+  #persistToState(): void {
+    const cloned: Record<string, DeferredStatusUpdateEntry> = {};
+    for (const [key, entry] of this.#deferredRetryQueue) {
+      cloned[key] = { ...entry, pendingStatuses: [...entry.pendingStatuses] };
+    }
+    this.#persistDeferredUpdates(cloned);
+  }
+
+  readonly #updateQuoteStatus = async (
+    quoteId: string,
+    srcTxHash: string,
+    newStatus: string,
+  ): Promise<void> => {
+    await this.#fetchFn(`${this.#apiBaseUrl}/quote/updateStatus`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...getClientHeaders({
+          clientId: this.#clientId,
+          jwt: await getJwt(this.#messenger),
+        }),
+      },
+      body: JSON.stringify({
+        quoteId,
+        newStatus,
+        srcTxHash,
+      }),
+    });
+  };
+}
diff --git a/packages/bridge-status-controller/src/types.ts b/packages/bridge-status-controller/src/types.ts
index 20ba3f21619..3fef9a0c174 100644
--- a/packages/bridge-status-controller/src/types.ts
+++ b/packages/bridge-status-controller/src/types.ts
@@ -32,6 +32,7 @@ import type {
   TransactionControllerTransactionConfirmedEvent,
   TransactionControllerTransactionFailedEvent,
   TransactionControllerUpdateTransactionAction,
+  TransactionControllerTransactionSubmittedEvent,
   TransactionMeta,
 } from '@metamask/transaction-controller';
 import type { CaipAssetType } from '@metamask/utils';
@@ -253,8 +254,18 @@ export type StartPollingForBridgeTxStatusArgsSerialized = Omit<
 
 export type SourceChainTxMetaId = string;
 
+export type DeferredStatusUpdateEntry = {
+  quoteId: string;
+  srcTxHash: string;
+  pendingStatuses: string[];
+  createdAt: number;
+  lastAttemptAt: number;
+  txMetaId?: string;
+};
+
 export type BridgeStatusControllerState = {
   txHistory: Record<SourceChainTxMetaId, BridgeHistoryItem>;
+  deferredStatusUpdates: Record<string, DeferredStatusUpdateEntry>;
 };
 
 // Actions
@@ -310,7 +321,8 @@ type AllowedActions =
  */
 type AllowedEvents =
   | TransactionControllerTransactionFailedEvent
-  | TransactionControllerTransactionConfirmedEvent;
+  | TransactionControllerTransactionConfirmedEvent
+  | TransactionControllerTransactionSubmittedEvent;
 
 /**
  * The messenger for the BridgeStatusController.