@@ -19,6 +19,7 @@ import type { Clip } from "~/types/clip";
 import { $ } from "~/generated/zeus";
 import { typedGql } from "~/generated/zeus/typedDocumentNode";
 import { matchClipFields, topPlayOrderBy } from "~/graphql/matchClip";
+import { tournamentPodiumQuery } from "~/graphql/tournamentPodium";
 import {
   daysUntil,
   formatEventRange,
@@ -213,10 +214,49 @@ const liveTournaments = computed(() =>
     (tournament: any) => tournamentStatusVariant(tournament.status) === "live",
   ),
 );
+// Fetched once per finished tournament rather than selected in the event
+// subscription, which Hasura re-runs every second for every viewer.
+const podiums = ref<Record<string, unknown>>({});
+watch(
+  () =>
+    tournaments.value
+      .filter(
+        (tournament: any) =>
+          tournament.status === "Finished" && !(tournament.id in podiums.value),
+      )
+      .map((tournament: any) => tournament.id as string),
+  (ids) => {
+    for (const id of ids) {
+      podiums.value = { ...podiums.value, [id]: null };
+      apolloClient
+        .query({
+          query: tournamentPodiumQuery,
+          variables: { tournamentId: id },
+          context: { optional: true },
+        })
+        .then(({ data }) => {
+          podiums.value = {
+            ...podiums.value,
+            [id]: (data as any)?.tournaments_by_pk?.podium ?? null,
+          };
+        })
+        .catch(() => {});
+    }
+  },
+  { immediate: true },
+);
+
 const otherTournaments = computed(() =>
-  tournaments.value.filter(
-    (tournament: any) => tournamentStatusVariant(tournament.status) !== "live",
-  ),
+  tournaments.value
+    .filter(
+      (tournament: any) =>
+        tournamentStatusVariant(tournament.status) !== "live",
+    )
+    .map((tournament: any) =>
+      podiums.value[tournament.id]
+        ? { ...tournament, podium: podiums.value[tournament.id] }
+        : tournament,
+    ),
 );
 
 // "Sign up" only while something is open; "Champions" only once every one
 
@@ -270,6 +270,11 @@ export default {
       type: Array,
       default: () => [],
     },
+    // The finished tournament's placements, for its final stage only.
+    placements: {
+      type: Array,
+      default: () => [],
+    },
   },
   data() {
     return {
@@ -284,6 +289,15 @@ export default {
       if (this.onlyGroup != null) return false;
       return this.forceGroupHeading || this.totalGroups > 1;
     },
+    placementByTeam() {
+      const map = new Map<string, number>();
+      for (const step of (this.placements as any[]) || []) {
+        if (step?.tournament_team_id && Number(step.placement) > 0) {
+          map.set(String(step.tournament_team_id), Number(step.placement));
+        }
+      }
+      return map;
+    },
     statsByPlayer() {
       const map = new Map<string, any>();
       for (const s of (this.playerStats as any[]) || []) {
@@ -318,11 +332,21 @@ export default {
       for (const gn of numbers) {
         if (this.onlyGroup != null && this.onlyGroup !== gn) continue;
         const rows = grouped.get(gn) || [];
-        const sorted = rows
-          .slice()
-          .sort(
-            (a: any, b: any) => (Number(a.rank) || 0) - (Number(b.rank) || 0),
+        const placementOf = (row: any) =>
+          this.placementByTeam.get(
+            String(row.tournament_team_id || row.team?.id),
           );
+        // A placed team ranks by its placement, which is what the podium
+        // shows; the tiebreakers only order the teams after them.
+        const sorted = rows.slice().sort((a: any, b: any) => {
+          const placedA = placementOf(a);
+          const placedB = placementOf(b);
+          if (placedA !== placedB) {
+            return (placedA ?? Infinity) - (placedB ?? Infinity);
+          }
+          return (Number(a.rank) || 0) - (Number(b.rank) || 0);
+        });
+        const placed = sorted.filter((row: any) => placementOf(row)).length;
 
         // Tied iff multiple teams share the same `placement` (RANK with ties)
         // from the API. `rank` itself is a deterministic ROW_NUMBER and never
@@ -336,20 +360,26 @@ export default {
           placementCounts.set(p, (placementCounts.get(p) || 0) + 1);
         }
 
-        const entries = sorted.map((row: any) => ({
-          rank: Number(row.rank) || 0,
-          teamId: row.tournament_team_id || row.team?.id,
-          teamLinkId: row.team?.team?.id || null,
-          teamName: this.displayTeamName(
-            row.team,
-            row.tournament_team_id || row.team?.id,
-          ),
-          wins: Number(row.wins) || 0,
-          losses: Number(row.losses) || 0,
-          matchesPlayed: Number(row.matches_played) || 0,
-          tied: (placementCounts.get(Number(row.placement) || 0) || 0) > 1,
-          roster: (row.team?.roster || []).filter((m: any) => m?.player),
-        }));
+        const entries = sorted.map((row: any, index: number) => {
+          const placement = placementOf(row);
+          return {
+            rank: placement ?? (placed ? index + 1 : Number(row.rank) || 0),
+            teamId: row.tournament_team_id || row.team?.id,
+            teamLinkId: row.team?.team?.id || null,
+            teamName: this.displayTeamName(
+              row.team,
+              row.tournament_team_id || row.team?.id,
+            ),
+            wins: Number(row.wins) || 0,
+            losses: Number(row.losses) || 0,
+            matchesPlayed: Number(row.matches_played) || 0,
+            tied: placement
+              ? sorted.filter((other: any) => placementOf(other) === placement)
+                  .length > 1
+              : (placementCounts.get(Number(row.placement) || 0) || 0) > 1,
+            roster: (row.team?.roster || []).filter((m: any) => m?.player),
+          };
+        });
         out.push({
           number: gn,
           display: this.groupDisplay(gn),
 
@@ -102,11 +102,21 @@ function teamNameForResult(row: any): string | null {
   );
 }
 
+// The tournament's placements first, the ones its podium and medals read; then
+// a placement award they don't name.
 const podium = computed(() => {
   const awards = (props.tournament?.awards || []) as any[];
   const byPlacement: Record<number, string | null> = {};
+  for (const step of (props.tournament?.podium || []) as any[]) {
+    const placement = Number(step.placement);
+    if (placement >= 1 && placement <= 3 && step.name) {
+      byPlacement[placement] = byPlacement[placement]
+        ? `${byPlacement[placement]} · ${step.name}`
+        : step.name;
+    }
+  }
   for (const t of awards) {
-    if (t.placement >= 1 && t.placement <= 3) {
+    if (t.placement >= 1 && t.placement <= 3 && !byPlacement[t.placement]) {
       byPlacement[t.placement] = teamNameForAward(t);
     }
   }
 
@@ -11,7 +11,8 @@ import {
 } from "lucide-vue-next";
 import { Button } from "~/components/ui/button";
 import { typedGql } from "~/generated/zeus/typedDocumentNode";
-import { $, order_by } from "~/generated/zeus";
+import { $, e_tournament_status_enum, order_by } from "~/generated/zeus";
+import { tournamentPodiumQuery } from "~/graphql/tournamentPodium";
 import { useAuthStore } from "~/stores/AuthStore";
 import { useApplicationSettingsStore } from "~/stores/ApplicationSettings";
 import { loginLinks } from "~/utilities/loginLinks";
@@ -72,6 +73,15 @@ const { result } = useQuery(
   () => ({ id: props.tournament.id }),
 );
 
+const { result: podiumResult } = useQuery(
+  tournamentPodiumQuery,
+  () => ({ tournamentId: props.tournament.id }),
+  () => ({
+    enabled: props.tournament.status === e_tournament_status_enum.Finished,
+    context: { optional: true },
+  }),
+);
+
 const details = computed(() => (result.value as any)?.tournaments_by_pk);
 const event = computed(() =>
   useApplicationSettingsStore().eventsEnabled
@@ -133,8 +143,24 @@ const requirements = computed(() => {
   return list;
 });
 
-// Final stage's standings, best first.
+const podiumSteps = computed<any[]>(
+  () => (podiumResult.value as any)?.tournaments_by_pk?.podium ?? [],
+);
+
+// The tournament's placements, which the podium reads; the final stage's
+// standings when the api has none.
 const podium = computed(() => {
+  const placed = podiumSteps.value
+    .filter((step) => step.name && step.placement >= 1 && step.placement <= 3)
+    .map((step) => ({
+      key: `${step.placement}-${step.tournament_team_id}`,
+      rank: Number(step.placement),
+      name: step.name,
+    }))
+    .sort((a, b) => a.rank - b.rank);
+  if (placed.length) {
+    return placed;
+  }
   const stages = [...(props.tournament.stages || [])].sort(
     (a: any, b: any) => (b.order ?? 0) - (a.order ?? 0),
   );
@@ -143,6 +169,7 @@ const podium = computed(() => {
     .sort((a: any, b: any) => a.rank - b.rank)
     .slice(0, 3)
     .map((row: any) => ({
+      key: String(row.rank),
       rank: row.rank,
       name: row.team?.team?.name || row.team?.name,
     }));
@@ -346,7 +373,7 @@ const section = "grid gap-2.5 border-t border-border/65 pt-4";
       <ol class="m-0 grid list-none gap-1 p-0">
         <li
           v-for="row in podium"
-          :key="row.rank"
+          :key="row.key"
           class="grid grid-cols-[2.25rem_minmax(0,1fr)] items-center gap-2 py-1 text-sm"
         >
           <span
 
@@ -569,6 +569,7 @@ function playerAvatarSrc(player: {
           <StageStandings
             :stage="stage"
             :player-stats="tournamentPlayerStats"
+            :placements="stage.id === finalStageId ? podiumSteps || [] : []"
           />
         </CardContent>
       </Card>
@@ -586,6 +587,7 @@ function playerAvatarSrc(player: {
 import { $, e_tournament_status_enum } from "~/generated/zeus";
 import { typedGql } from "~/generated/zeus/typedDocumentNode";
 import { TIER_PALETTES, resolveAwardTier } from "~/utilities/awardSeed";
+import { tournamentPodiumQuery } from "~/graphql/tournamentPodium";
 
 export default {
   props: {
@@ -609,12 +611,7 @@ export default {
     // Its own optional query, so an api without the podium field only loses
     // this and falls back to the podium built from the awards.
     podiumSteps: {
-      query: typedGql("query")({
-        tournaments_by_pk: [
-          { id: $("tournamentId", "uuid!") },
-          { id: true, podium: true } as any,
-        ],
-      }),
+      query: tournamentPodiumQuery,
       variables: function () {
         return { tournamentId: (this as any).tournament?.id };
       },
@@ -822,6 +819,10 @@ export default {
       const stages = (this.tournament as any)?.stages || [];
       return stages.length ? stages[stages.length - 1]?.type || null : null;
     },
+    finalStageId() {
+      const stages = (this.tournament as any)?.stages || [];
+      return stages.length ? stages[stages.length - 1]?.id || null : null;
+    },
     // The tournament's placements, plus any placement award granted to a team
     // they don't name (an organizer's own 3rd); the awards alone when the api
     // has no placements to give.
 
@@ -0,0 +1,11 @@
+import { $ } from "~/generated/zeus";
+import { typedGql } from "~/generated/zeus/typedDocumentNode";
+
+// The finished tournament's placements (api#588). Run with
+// `context: { optional: true }`, so an api without the field only loses them.
+export const tournamentPodiumQuery = typedGql("query")({
+  tournaments_by_pk: [
+    { id: $("tournamentId", "uuid!") },
+    { id: true, podium: true } as any,
+  ],
+});