diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2512b6299..857eec2f3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -59,6 +59,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- A mediator that answers with a non-2xx HTTP status no longer discards the collected provider bids. The orchestrator now logs a warning and ranks those bids locally with floors, as it already did for mediator launch, transport, deadline and parse failures (#1203). A mediator response reported with an error status falls back the same way. An HTTP 204 from the `adserver_mock` mediator is a final no-bid, matching how bidder providers treat 204.
+- Auction telemetry now marks the bid that local ranking selected as the slot's winner. When one bidder code returned several bids for a slot without distinguishing ad IDs, an earlier lower-priced bid, possibly from another provider, was marked as the win at its own price. Tinybird per-provider win counts and winning-CPM quantiles for those slots shift after upgrading. Mediated wins keep their provider association unless the mediator returns a provider bid's own ID and price; that exact bid is then marked.
 - Lockr and Permutive SDK recognition now uses parsed vendor hostnames and SDK pathnames instead of searching the whole URL (#1199). The browser Lockr guard no longer replaces unrelated scripts that mention a Lockr host in their path or query, use a lookalike host, or serve a non-SDK resource from a Lockr host. Query strings and fragments no longer prevent SDK recognition in the server matchers, the browser Permutive guard, or the browser Lockr guard on `identity.loc.kr`. Matching URLs use the existing configured-SDK routes; their original query and fragment are not forwarded upstream. Server matching trims leading and trailing C0 controls and spaces, removes tab, CR, and LF, and accepts backslashes as authority separators. It no longer recognizes attribute values that contain a NUL or that write slashes as character references such as `/`, so markup like that can load the SDK from the vendor host.
 - `rewrite.exclude_domains` matching is now case-insensitive and ignores surrounding whitespace. Entries written with uppercase letters previously never matched and now take effect, so those hosts stop being proxied and click-wrapped, and `/first-party/sign` now rejects them with `502`; it used to sign them, or return `403` when the host was also outside `proxy.allowed_domains`. Empty and bare `"*"` `exclude_domains` entries, which never matched a host, are dropped at load with a warning, and other entries that can never match a host are logged with a warning. Absolute `http(s)` creative URLs that cannot be parsed (for example, a host containing a space) are now left untouched; previously the trimmed value was written back re-quoted (with `https:` prepended to `//` input, so `src=" //example.com invalid/x "` became `https://example.com invalid/x`), an unparseable quoted URL in `<style>` or `style=` was re-quoted through `cssparser::serialize_string`, and a link also gained `data-tsclick`. `/first-party/sign` now answers unparseable `http(s)` input with `unsupported url` instead of `invalid url`; both map to `502`. The first `ts config push` after upgrading shows a one-time `exclude_domains` diff for configs with mixed-case, padded, empty or bare `"*"` entries. Audit `exclude_domains` for mixed-case entries before upgrading.
 - Next.js and Google Tag Manager script rewrites now compose in streamed HTML instead of overwriting each other, preserving Pages Router JSON and App Router Flight payloads with recomputed decoded `T`-record lengths. GTM/GA Flight rewrites require both integrations to be enabled. Buffering is bounded and per document; an uncaptured data head (including inert text quoting a Flight push), an unsupported or binary push, or a size limit keeps the remaining Flight stream raw and restores queued originals, but cannot undo already-streamed rewrites. Complete serialized form state does not disable later rewriting, foreign property references no longer hide a later qualified Flight push, and placeholder-stage document fallback emits a reason-bearing warning without source data (#1206, #1207, #1208).
diff --git a/crates/trusted-server-core/src/auction/orchestrator.rs b/crates/trusted-server-core/src/auction/orchestrator.rs
index f66544172..fb229faa5 100644
--- a/crates/trusted-server-core/src/auction/orchestrator.rs
+++ b/crates/trusted-server-core/src/auction/orchestrator.rs
@@ -756,7 +756,7 @@ impl AuctionOrchestratorHarness {
                                     .await
                                     .map_err(|error| {
                                         log::warn!(
-                                            "Planned mediator '{}' parse failed: {:?}",
+                                            "Planned mediator '{}' response processing failed; using local ranking: {:?}",
                                             mediator.provider_name(),
                                             error
                                         );
@@ -792,7 +792,20 @@ impl AuctionOrchestratorHarness {
                         None
                     }
                 };
-                if let Some(mediated) = mediated {
+                // An error status is not a mediation decision, however the provider
+                // reports it, so it falls back to local ranking like other failures.
+                if mediated
+                    .as_ref()
+                    .is_some_and(|response| response.status == BidStatus::Error)
+                {
+                    log::warn!(
+                        "Planned mediator '{}' reported an error response; using local ranking",
+                        mediator.provider_name()
+                    );
+                }
+                if let Some(mediated) =
+                    mediated.filter(|response| response.status != BidStatus::Error)
+                {
                     let winners = mediated
                         .bids
                         .iter()
@@ -1570,6 +1583,11 @@ impl AuctionOrchestrator {
     }
 
     /// Select the best decoded-price bid for each slot from all responses.
+    ///
+    /// Winning bids are verbatim clones of provider bids, and floor enforcement
+    /// only removes entries. Auction telemetry attributes local wins by matching
+    /// `bid_id` and `price`, so any future change that rewrites a winner (for
+    /// example currency conversion or bid shading) must update that matching too.
     fn select_winning_bids(
         &self,
         responses: &[AuctionResponse],
@@ -2648,7 +2666,7 @@ impl AuctionOrchestrator {
                                     }
                                     Err(error) => {
                                         log::warn!(
-                                            "Mediator '{}' parse failed: {:?}",
+                                            "Mediator '{}' response processing failed; using local ranking: {:?}",
                                             mediator.provider_name(),
                                             error
                                         );
@@ -2686,7 +2704,20 @@ impl AuctionOrchestrator {
                     trace.observe_failure(observation);
                 }
 
-                if let Some(mediator_response) = mediator_response {
+                // An error status is not a mediation decision, however the provider
+                // reports it, so it falls back to local ranking like other failures.
+                if mediator_response
+                    .as_ref()
+                    .is_some_and(|response| response.status == BidStatus::Error)
+                {
+                    log::warn!(
+                        "Mediator '{}' reported an error response; using local ranking",
+                        mediator.provider_name()
+                    );
+                }
+                if let Some(mediator_response) =
+                    mediator_response.filter(|response| response.status != BidStatus::Error)
+                {
                     let winning = mediator_response
                             .bids
                             .iter()
@@ -2798,11 +2829,16 @@ mod tests {
         AuctionProvider, GenericOpenRtbProvider, ProviderRequestOutcome,
     };
     use crate::auction::routing::{RoutingDiagnostics, route_auction};
+    use crate::auction::telemetry::{
+        AuctionObservationContext, AuctionSource, AuctionTerminalOutcome, build_auction_events,
+    };
     use crate::auction::test_support::create_test_auction_context;
     use crate::auction::types::{
         AdFormat, AdSlot, ApsRendererV1, ApsTagType, AuctionContext, AuctionRequest,
         AuctionResponse, Bid, BidRenderer, BidStatus, MediaType, PublisherInfo, UserInfo,
     };
+    use crate::consent::types::ConsentContext;
+    use crate::ec::EcContext;
     use crate::error::TrustedServerError;
     use crate::integrations::adserver_mock::{AdServerMockConfig, AdServerMockProvider};
     use crate::platform::test_support::{
@@ -7144,6 +7180,312 @@ mod tests {
         }
     }
 
+    async fn run_mock_mediator_response(
+        harness: bool,
+        status: u16,
+        body: &serde_json::Value,
+        floor: f64,
+    ) -> (AuctionRequest, OrchestrationResult) {
+        let body = serde_json::to_vec(body).expect("should serialize mediator response");
+        run_raw_mock_mediator_response(harness, status, body, floor).await
+    }
+
+    async fn run_raw_mock_mediator_response(
+        harness: bool,
+        status: u16,
+        body: Vec<u8>,
+        floor: f64,
+    ) -> (AuctionRequest, OrchestrationResult) {
+        let mediator = Arc::new(AdServerMockProvider::new(AdServerMockConfig {
+            enabled: true,
+            endpoint: "https://mediator.example/mediate".to_string(),
+            timeout_ms: 500,
+            ..AdServerMockConfig::default()
+        }));
+        run_mediated_provider_auction(harness, mediator, Some((status, body)), floor).await
+    }
+
+    /// Runs a planned auction whose single provider returns bids at 1.5 and 2.0.
+    ///
+    /// `mediator_http` is the stubbed mediator HTTP reply, or `None` for a
+    /// mediator that answers without HTTP.
+    async fn run_mediated_provider_auction(
+        harness: bool,
+        mediator: Arc<dyn AuctionProvider>,
+        mediator_http: Option<(u16, Vec<u8>)>,
+        floor: f64,
+    ) -> (AuctionRequest, OrchestrationResult) {
+        let http = Arc::new(StubHttpClient::new());
+        http.push_response(
+            200,
+            serde_json::to_vec(&serde_json::json!({
+                "seatbid": [{"seat": "provider-seat", "bid": [
+                    {"id": "lower", "impid": "fictional-slot", "price": 1.5,
+                     "adm": "<div>lower</div>", "w": 300, "h": 250},
+                    {"id": "higher", "impid": "fictional-slot", "price": 2.0,
+                     "adm": "<div>higher</div>", "w": 300, "h": 250}
+                ]}]
+            }))
+            .expect("should serialize provider bids"),
+        );
+        if let Some((status, body)) = mediator_http {
+            http.push_response(status, body);
+        }
+        let backend = Arc::new(NamingBackend::new(BackendNamingPolicy::Axum));
+        let services = build_services_with_backend_and_http_client(
+            Arc::clone(&backend) as Arc<_>,
+            Arc::clone(&http) as Arc<_>,
+        );
+        let plan = AuctionPlan::compile(planned_config(
+            &[("provider-a", RoutingMode::AllEligible)],
+            false,
+        ))
+        .expect("should compile planned auction");
+        let mut request = planned_request();
+        request.slots[0].floor_price = Some(floor);
+        let settings = create_test_settings();
+        let inbound = http::Request::new(edgezero_core::body::Body::empty());
+        let context = AuctionContext {
+            settings: &settings,
+            request: &inbound,
+            timeout_ms: 777,
+            transport_timeout_ms: 777,
+            provider_responses: None,
+            services: &services,
+        };
+
+        let result = if harness {
+            AuctionOrchestratorHarness::new(plan, Some(mediator))
+                .run_auction(&request, &context)
+                .await
+        } else {
+            AuctionOrchestrator::from_plan(Arc::new(plan), Some(mediator))
+                .run_auction(&request, &context)
+                .await
+        }
+        .expect("should complete auction with mock mediation");
+
+        (request, result)
+    }
+
+    async fn assert_mediator_non_success_falls_back(harness: bool) {
+        for status in [302, 400, 503] {
+            for floor in [1.0, 3.0] {
+                let (request, result) = run_mock_mediator_response(
+                    harness,
+                    status,
+                    &serde_json::json!({"seatbid": []}),
+                    floor,
+                )
+                .await;
+                let expected_winner = if floor < 2.0 { Some("higher") } else { None };
+                assert_eq!(
+                    result
+                        .winning_bids
+                        .get("fictional-slot")
+                        .and_then(|bid| bid.bid_id.as_deref()),
+                    expected_winner,
+                    "should rank provider bids locally with floors after HTTP {status} (harness={harness})"
+                );
+                assert_eq!(
+                    result.provider_responses[0].bids.len(),
+                    2,
+                    "should retain both collected provider bids"
+                );
+                assert!(
+                    result.mediator_response.is_none(),
+                    "should treat HTTP {status} as failed mediation"
+                );
+
+                let ec_context = EcContext::new_for_test(None, ConsentContext::default());
+                let observation = AuctionObservationContext::from_auction_request(
+                    AuctionSource::AuctionApi,
+                    &request,
+                    &ec_context,
+                );
+                let events = build_auction_events(
+                    observation,
+                    AuctionTerminalOutcome::Completed {
+                        request: &request,
+                        result: &result,
+                        delivered_winner_slots: None,
+                    },
+                );
+                assert!(
+                    !events
+                        .rows()
+                        .iter()
+                        .any(|row| row.provider_role.as_deref() == Some("mediator")),
+                    "should omit failed mediator rows consistently with other mediation failures"
+                );
+                assert_eq!(
+                    events
+                        .rows()
+                        .iter()
+                        .find(|row| row.event_kind == "summary")
+                        .and_then(|row| row.winning_bid_count),
+                    Some(u16::from(expected_winner.is_some())),
+                    "should count locally selected winners in telemetry"
+                );
+                let bid_rows = events
+                    .rows()
+                    .iter()
+                    .filter(|row| row.event_kind == "bid")
+                    .map(|row| (row.price_cpm, row.is_win))
+                    .collect::<Vec<_>>();
+                assert_eq!(
+                    bid_rows,
+                    vec![
+                        (Some(1.5), Some(0)),
+                        (Some(2.0), Some(u8::from(expected_winner.is_some()))),
+                    ],
+                    "should mark only the selected provider bid as winning after HTTP {status} (harness={harness})"
+                );
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn mediator_non_success_status_falls_back_to_local_ranking() {
+        assert_mediator_non_success_falls_back(false).await;
+    }
+
+    #[tokio::test]
+    async fn planned_executor_mediator_non_success_status_falls_back_locally() {
+        assert_mediator_non_success_falls_back(true).await;
+    }
+
+    #[tokio::test]
+    async fn mock_mediator_success_and_no_bid_remain_authoritative() {
+        for harness in [false, true] {
+            for has_winner in [false, true] {
+                let body = if has_winner {
+                    serde_json::json!({"seatbid": [{"seat": "provider-a", "bid": [{
+                        "id": "mediated", "impid": "fictional-slot", "price": 1.75,
+                        "adm": "<div>mediated</div>", "w": 300, "h": 250
+                    }]}]})
+                } else {
+                    serde_json::json!({"seatbid": []})
+                };
+                let (_, result) = run_mock_mediator_response(harness, 200, &body, 1.0).await;
+                assert!(
+                    result.mediator_response.is_some(),
+                    "should preserve a valid mediation result, including no-bid"
+                );
+                assert_eq!(
+                    result
+                        .winning_bids
+                        .get("fictional-slot")
+                        .and_then(|bid| bid.bid_id.as_deref()),
+                    if has_winner { Some("mediated") } else { None },
+                    "should honor the mediator decision instead of the higher local bid"
+                );
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn mock_mediator_no_content_is_a_final_no_bid() {
+        for harness in [false, true] {
+            let (_, result) = run_raw_mock_mediator_response(harness, 204, Vec::new(), 1.0).await;
+            assert_eq!(
+                result
+                    .mediator_response
+                    .as_ref()
+                    .map(|response| response.status.clone()),
+                Some(BidStatus::NoBid),
+                "should record a bodiless HTTP 204 as a mediation no-bid (harness={harness})"
+            );
+            assert!(
+                result.winning_bids.is_empty(),
+                "should keep the mediator's no-bid instead of ranking provider bids (harness={harness})"
+            );
+        }
+    }
+
+    struct ErrorStatusMediator;
+
+    #[async_trait::async_trait(?Send)]
+    impl AuctionProvider for ErrorStatusMediator {
+        fn provider_name(&self) -> &str {
+            "error-status-mediator"
+        }
+
+        async fn request_bids(
+            &self,
+            _request: &AuctionRequest,
+            _context: &AuctionContext<'_>,
+        ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
+            Ok(ProviderRequestOutcome::Immediate(AuctionResponse::error(
+                self.provider_name(),
+                3,
+            )))
+        }
+
+        async fn parse_response(
+            &self,
+            _response: PlatformResponse,
+            _response_time_ms: u64,
+        ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+            panic!("error-status mediator response should not be parsed");
+        }
+
+        fn timeout_ms(&self) -> u32 {
+            500
+        }
+    }
+
+    #[tokio::test]
+    async fn mediator_error_status_response_falls_back_to_local_ranking() {
+        for harness in [false, true] {
+            for floor in [1.0, 3.0] {
+                let (_, result) = run_mediated_provider_auction(
+                    harness,
+                    Arc::new(ErrorStatusMediator),
+                    None,
+                    floor,
+                )
+                .await;
+                assert!(
+                    result.mediator_response.is_none(),
+                    "should treat an error-status mediator response as failed mediation (harness={harness})"
+                );
+                assert_eq!(
+                    result
+                        .winning_bids
+                        .get("fictional-slot")
+                        .and_then(|bid| bid.bid_id.as_deref()),
+                    if floor < 2.0 { Some("higher") } else { None },
+                    "should rank provider bids locally with floors (harness={harness}, floor={floor})"
+                );
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn mediator_error_status_response_logs_local_ranking_fallback() {
+        for (harness, expected) in [
+            (
+                false,
+                "Mediator 'error-status-mediator' reported an error response; using local ranking",
+            ),
+            (
+                true,
+                "Planned mediator 'error-status-mediator' reported an error response; using local ranking",
+            ),
+        ] {
+            let warnings = crate::test_support::logging::WarningCapture::start();
+            run_mediated_provider_auction(harness, Arc::new(ErrorStatusMediator), None, 1.0).await;
+            assert!(
+                warnings
+                    .take()
+                    .iter()
+                    .any(|warning| warning.message == expected),
+                "should warn when an error-status mediator response falls back to local ranking (harness={harness})"
+            );
+        }
+    }
+
     #[tokio::test]
     async fn planned_executor_mediator_transport_failure_falls_back_locally() {
         let http = Arc::new(StubHttpClient::new());
diff --git a/crates/trusted-server-core/src/auction/telemetry.rs b/crates/trusted-server-core/src/auction/telemetry.rs
index e0a819ba3..d718ee076 100644
--- a/crates/trusted-server-core/src/auction/telemetry.rs
+++ b/crates/trusted-server-core/src/auction/telemetry.rs
@@ -745,6 +745,21 @@ fn push_bid_rows(
     delivered_winner_slots: Option<&HashSet<String>>,
 ) {
     let mut matched_wins = HashSet::new();
+    // Local ranking clones the selected bid, so its winner has an exact provider
+    // match. Mediation may rewrite the ID or price; only those slots fall back to
+    // the looser provider association.
+    let exact_winner_slots = result
+        .winning_bids
+        .iter()
+        .filter(|(_, winning)| {
+            result
+                .provider_responses
+                .iter()
+                .flat_map(|response| &response.bids)
+                .any(|bid| is_exact_winning_bid(bid, winning))
+        })
+        .map(|(slot_id, _)| slot_id.as_str())
+        .collect::<HashSet<_>>();
 
     for response in &result.provider_responses {
         for bid in &response.bids {
@@ -755,6 +770,8 @@ fn push_bid_rows(
                     delivered_winner_slots.is_none_or(|slots| slots.contains(*slot_id))
                         && !matched_wins.contains(*slot_id)
                         && bid_matches_winning_bid(bid, winning)
+                        && (is_exact_winning_bid(bid, winning)
+                            || !exact_winner_slots.contains(slot_id.as_str()))
                 })
                 .map(|(slot_id, winning)| (slot_id.clone(), winning));
             let (is_win, price) = if let Some((slot_id, winning)) = matched_slot {
@@ -843,6 +860,12 @@ fn bid_matches_winning_bid(candidate: &Bid, winning: &Bid) -> bool {
     }
 }
 
+fn is_exact_winning_bid(candidate: &Bid, winning: &Bid) -> bool {
+    bid_matches_winning_bid(candidate, winning)
+        && candidate.bid_id == winning.bid_id
+        && candidate.price == winning.price
+}
+
 fn media_type_for_slot<'a>(request: &'a AuctionRequest, slot_id: &str) -> Option<&'a str> {
     request
         .slots
@@ -1451,12 +1474,200 @@ mod tests {
         );
     }
 
+    #[test]
+    fn local_winner_rows_identify_the_selected_bid() {
+        for (lower_id, higher_id) in [
+            (None, None),
+            (Some("lower"), Some("higher")),
+            (Some("shared"), Some("shared")),
+        ] {
+            for ad_id in [None, Some("shared-ad")] {
+                for separate_providers in [false, true] {
+                    let request = test_request("local-auction");
+                    let mut lower = bid("slot-1", "example-bidder", ad_id, Some(1.5));
+                    lower.bid_id = lower_id.map(String::from);
+                    let mut higher = bid("slot-1", "example-bidder", ad_id, Some(2.0));
+                    higher.bid_id = higher_id.map(String::from);
+                    let winner = higher.clone();
+                    let provider_responses = if separate_providers {
+                        vec![
+                            AuctionResponse::success("provider-a", vec![lower], 1),
+                            AuctionResponse::success("provider-b", vec![higher], 2),
+                        ]
+                    } else {
+                        vec![AuctionResponse::success(
+                            "provider-a",
+                            vec![lower, higher],
+                            2,
+                        )]
+                    };
+                    let result = OrchestrationResult {
+                        provider_responses,
+                        mediator_response: None,
+                        winning_bids: HashMap::from([("slot-1".to_owned(), winner)]),
+                        total_time_ms: 2,
+                        metadata: HashMap::new(),
+                    };
+                    let events = build_auction_events(
+                        AuctionObservationContext::for_test(
+                            AuctionSource::AuctionApi,
+                            "/auction",
+                            1,
+                        ),
+                        AuctionTerminalOutcome::Completed {
+                            request: &request,
+                            result: &result,
+                            delivered_winner_slots: None,
+                        },
+                    );
+                    let rows = events
+                        .rows()
+                        .iter()
+                        .filter(|row| row.event_kind == "bid")
+                        .map(|row| (row.provider.as_deref(), row.price_cpm, row.is_win))
+                        .collect::<Vec<_>>();
+                    let winning_provider = if separate_providers {
+                        "provider-b"
+                    } else {
+                        "provider-a"
+                    };
+                    assert_eq!(
+                        rows,
+                        vec![
+                            (Some("provider-a"), Some(1.5), Some(0)),
+                            (Some(winning_provider), Some(2.0), Some(1)),
+                        ],
+                        "should attribute the win and CPM to the selected bid even with absent or reused IDs"
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn local_winner_is_attributed_when_failed_mediator_response_is_kept() {
+        let request = test_request("failed-mediation");
+        let lower = bid("slot-1", "example-bidder", None, Some(1.5));
+        let higher = bid("slot-1", "example-bidder", None, Some(2.0));
+        let result = OrchestrationResult {
+            provider_responses: vec![AuctionResponse::success(
+                "provider-a",
+                vec![lower, higher.clone()],
+                2,
+            )],
+            mediator_response: Some(AuctionResponse::error("adserver_mock", 3)),
+            winning_bids: HashMap::from([("slot-1".to_owned(), higher)]),
+            total_time_ms: 5,
+            metadata: HashMap::new(),
+        };
+        let events = build_auction_events(
+            AuctionObservationContext::for_test(AuctionSource::AuctionApi, "/auction", 1),
+            AuctionTerminalOutcome::Completed {
+                request: &request,
+                result: &result,
+                delivered_winner_slots: None,
+            },
+        );
+        let rows = events
+            .rows()
+            .iter()
+            .filter(|row| row.event_kind == "bid")
+            .map(|row| (row.price_cpm, row.is_win))
+            .collect::<Vec<_>>();
+        assert_eq!(
+            rows,
+            vec![(Some(1.5), Some(0)), (Some(2.0), Some(1))],
+            "should attribute the local winner even when a failed mediator response is kept"
+        );
+    }
+
+    #[test]
+    fn mediated_winner_keeping_provider_identity_marks_that_bid() {
+        let request = test_request("identity-preserving-mediation");
+        let mut lower = bid("slot-1", "example-bidder", None, Some(1.5));
+        lower.bid_id = Some("lower".to_owned());
+        let mut higher = bid("slot-1", "example-bidder", None, Some(2.0));
+        higher.bid_id = Some("higher".to_owned());
+        let result = OrchestrationResult {
+            provider_responses: vec![AuctionResponse::success(
+                "provider-a",
+                vec![lower, higher.clone()],
+                2,
+            )],
+            mediator_response: Some(AuctionResponse::success(
+                "adserver_mock",
+                vec![higher.clone()],
+                3,
+            )),
+            winning_bids: HashMap::from([("slot-1".to_owned(), higher)]),
+            total_time_ms: 5,
+            metadata: HashMap::new(),
+        };
+        let events = build_auction_events(
+            AuctionObservationContext::for_test(AuctionSource::AuctionApi, "/auction", 1),
+            AuctionTerminalOutcome::Completed {
+                request: &request,
+                result: &result,
+                delivered_winner_slots: None,
+            },
+        );
+        let rows = events
+            .rows()
+            .iter()
+            .filter(|row| row.event_kind == "bid")
+            .map(|row| (row.price_cpm, row.is_win))
+            .collect::<Vec<_>>();
+        assert_eq!(
+            rows,
+            vec![(Some(1.5), Some(0)), (Some(2.0), Some(1))],
+            "should mark the provider bid whose ID and price the mediator kept"
+        );
+    }
+
+    #[test]
+    fn local_tied_bids_keep_the_first_provider_as_the_only_winner() {
+        let request = test_request("tied-auction");
+        let first = bid("slot-1", "example-bidder", None, Some(2.0));
+        let second = first.clone();
+        let result = OrchestrationResult {
+            winning_bids: HashMap::from([("slot-1".to_owned(), first.clone())]),
+            provider_responses: vec![
+                AuctionResponse::success("provider-a", vec![first], 1),
+                AuctionResponse::success("provider-b", vec![second], 2),
+            ],
+            mediator_response: None,
+            total_time_ms: 2,
+            metadata: HashMap::new(),
+        };
+        let events = build_auction_events(
+            AuctionObservationContext::for_test(AuctionSource::AuctionApi, "/auction", 1),
+            AuctionTerminalOutcome::Completed {
+                request: &request,
+                result: &result,
+                delivered_winner_slots: None,
+            },
+        );
+        let winning_providers = events
+            .rows()
+            .iter()
+            .filter(|row| row.event_kind == "bid" && row.is_win == Some(1))
+            .map(|row| row.provider.as_deref())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            winning_providers,
+            vec![Some("provider-a")],
+            "should preserve local ranking's first-provider tie decision without duplicate wins"
+        );
+    }
+
     #[test]
     fn mediated_win_marks_original_bid_once() {
         let request = test_request("req");
-        let original_bid = bid("slot-1", "kargo", Some("ad-1"), None);
+        let mut original_bid = bid("slot-1", "example-bidder", Some("ad-1"), None);
+        original_bid.bid_id = Some("original-bid".to_owned());
         let provider_success = AuctionResponse::success("prebid", vec![original_bid], 42);
-        let mediator_bid = bid("slot-1", "kargo", Some("ad-1"), Some(2.0));
+        let mut mediator_bid = bid("slot-1", "example-bidder", Some("ad-1"), Some(2.0));
+        mediator_bid.bid_id = Some("mediated-bid".to_owned());
         let mediator_response =
             AuctionResponse::success("adserver_mock", vec![mediator_bid.clone()], 15);
         let result = OrchestrationResult {
diff --git a/crates/trusted-server-core/src/integrations/adserver_mock.rs b/crates/trusted-server-core/src/integrations/adserver_mock.rs
index efc789f3a..df841c4dd 100644
--- a/crates/trusted-server-core/src/integrations/adserver_mock.rs
+++ b/crates/trusted-server-core/src/integrations/adserver_mock.rs
@@ -7,7 +7,7 @@
 use async_trait::async_trait;
 use edgezero_core::body::Body as EdgeBody;
 use error_stack::{Report, ResultExt};
-use http::{Method, header};
+use http::{Method, StatusCode, header};
 use serde::{Deserialize, Serialize};
 use serde_json::{Value as Json, json};
 use std::collections::{BTreeMap, HashMap};
@@ -377,7 +377,8 @@ impl AdServerMockProvider {
     ///
     /// # Errors
     ///
-    /// Returns an error when the mediation response body is not valid JSON.
+    /// Returns an error when the mediation response has a non-success HTTP status,
+    /// its body cannot be read within the response limit, or it is not valid JSON.
     async fn parse_response_inner(
         &self,
         response: PlatformResponse,
@@ -387,9 +388,19 @@ impl AdServerMockProvider {
     ) -> Result<AuctionResponse, Report<TrustedServerError>> {
         let response = response.response;
 
+        // OpenRTB signals an empty auction with a bodiless 204, and the bidder
+        // providers already treat it that way. Keep it a final mediation no-bid.
+        if response.status() == StatusCode::NO_CONTENT {
+            return Ok(AuctionResponse::no_bid("adserver_mock", response_time_ms));
+        }
+
         if !response.status().is_success() {
-            log::warn!("AdServer Mock returned non-success: {}", response.status());
-            return Ok(AuctionResponse::error("adserver_mock", response_time_ms));
+            return Err(Report::new(TrustedServerError::Auction {
+                message: format!(
+                    "AdServer Mock returned non-success HTTP {}",
+                    response.status()
+                ),
+            }));
         }
 
         // collect_response_bounded caps memory from misbehaving providers.
diff --git a/docs/guide/auction-orchestration.md b/docs/guide/auction-orchestration.md
index 094212dc4..2dd9d3016 100644
--- a/docs/guide/auction-orchestration.md
+++ b/docs/guide/auction-orchestration.md
@@ -919,6 +919,7 @@ The orchestrator is designed to be resilient:
 - **Provider parse failure** — If a response can't be parsed, an `AuctionResponse::error()` is recorded. Other results are unaffected.
 - **No providers configured** — Completes as a no-bid without provider I/O.
 - **No provider produces a valid bid** — Returns an empty `OrchestrationResult` with zero winning bids after recording provider outcomes.
+- **Mediator failure** — If mediation fails (the mediator cannot launch or answer within the auction budget, its request fails, it returns a non-2xx HTTP status or an error-status response, or its response cannot be read or parsed), the orchestrator falls back to local ranking of collected provider bids with floor prices enforced. HTTP status, error-status and response parsing failures log a warning. As with other mediation failures, no mediator response or mediator telemetry row is recorded; the summary counts the locally selected winners. A valid successful no-bid response, including an HTTP 204, remains authoritative and does not trigger fallback.
 - **Mediator returns bids without decoded prices** — Those bids are filtered out with a warning.
 
 ## Observability
diff --git a/docs/guide/integrations/adserver_mock.md b/docs/guide/integrations/adserver_mock.md
index cc3fa4444..f3997f07f 100644
--- a/docs/guide/integrations/adserver_mock.md
+++ b/docs/guide/integrations/adserver_mock.md
@@ -10,6 +10,13 @@ when both conditions hold. The orchestrator first gathers responses from the
 configured auction providers, then passes successful bids to the mediator's
 HTTP endpoint for final selection.
 
+If the mediator request fails, returns a non-2xx HTTP status, or cannot be parsed,
+the orchestrator logs and falls back to local ranking of the collected provider
+bids, enforcing floor prices. A valid successful no-bid response remains final,
+and an HTTP 204 counts as one.
+Failed mediation produces no mediator response or mediator telemetry row, matching
+other mediation failures.
+
 The mediator supports banner bids. It omits bids without a decoded numeric
 price, applies the optional CPM floor, and restores render and accounting
 fields from the original provider bids after the mediation response. Duplicate