Beste en slechtste duizend dollar juni 2026

Wat was de beste optietrade van juni 2026 — en hoeveel zou een investering van duizend dollar zijn geworden? Het eerlijke antwoord bestaat uit vier onderdelen: de jackpot; de afwijkende penny print van twee contracten waar het nieuwsbericht op gebaseerd is; de negenduizend bijna volledige verliezen rondom deze trade; en de spiegeltrade — het VERKOOPEN van wat de winnaar kocht — waarbij duizend dollar aan geïnde premium een gat van zes cijfers werd. Alles wordt achteraf berekend op basis van de beursgegevens; een hindsight-optimal trade meet wat de maand bevatte, niet een strategie die iemand had kunnen uitvoeren. Elk getal is een resultaat van een query; open elk paneel voor de exacte SQL.

Hoe volatiel was juni 2026?

Heeft een optiewinst van honderd keer de inzet een historische maand op de markt nodig? Juni laat zien dat dit niet zo is. Het panel berekent elke maand van 2026 op dezelfde wijze — van de opening tot de sluiting tijdens de reguliere handelsuren, plus de range van hoog naar laag als percentage van de opening — voor SPY en NVDA, de basis van het winnende ticket. Juni kende 21 sessies.

SELECT toString(toStartOfMonth(toDate(toTimeZone(window_start, 'America/New_York')))) AS period_start,
    round((argMaxIf(toFloat64(close), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) / argMinIf(toFloat64(open), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - 1) * 100, 1) AS spy_month_pct,
    round((maxIf(toFloat64(high), ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - minIf(toFloat64(low), ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959)) / argMinIf(toFloat64(open), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) * 100, 1) AS spy_range_pct,
    round((argMaxIf(toFloat64(close), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) / argMinIf(toFloat64(open), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - 1) * 100, 1) AS nvda_month_pct,
    round((maxIf(toFloat64(high), ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - minIf(toFloat64(low), ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959)) / argMinIf(toFloat64(open), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) * 100, 1) AS nvda_range_pct,
    uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), ticker = 'SPY') AS trading_days
FROM global_markets.delayed_stocks_minute_aggs
WHERE ticker IN ('SPY', 'NVDA')
  AND window_start >= toDateTime('2026-01-01 05:00:00') AND window_start < toDateTime('2026-07-01 04:00:00')
GROUP BY period_start
HAVING uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), ticker = 'SPY') >= 17
ORDER BY period_start ASC

SPY sloot juni -1.2% van de opening binnen een range van 5.8% — een smaller bereik dan maart (8.7%) of april (11.4%). De beweging vond een niveau lager plaats: NVDA sloot -7.4% van de opening in juni na een range van 19.7% (de marktoverzicht van juni 2026 bevat het brede marktoverzicht). Een ticket met honderd keer de inzet had geen crashmaand nodig — het harde verval van één grote aandeel binnen twee weken was voldoende.

De grootste multiples van de maand

Het universum: elk contract op zes liquide roots met ten minste vijftig juni-trades — 30951 contracts — geprijsd van de eerste print op eerste juni tot de laatste, van beide zijden: wat de aankoop tegen de eerste print markeerde tegen de laatste, en wat de verkoop van duizend dollar aan premium uiteindelijk verschuldigd was.

SELECT ticker AS contract,
    substring(ticker, -9, 1) = 'P' AS is_put,
    round(first_px, 2) AS first_price,
    round(last_px, 2) AS last_price,
    round(last_px / first_px, 1) AS multiple,
    toUInt32(floor(1000 / (first_px * 100))) AS contracts_for_a_thousand,
    round(floor(1000 / (first_px * 100)) * last_px * 100, 0) AS bought_end_value_usd,
    round(1000 * (last_px / first_px) - 1000, 0) AS sold_net_loss_usd,
    trades
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
ORDER BY multiple DESC, contract ASC
LIMIT 5

De winnaar was een put: O:NVDA260629P00200000, eerst geprijsd op $0.01 en als laatste geprijsd op $4.95 — een multiple van 495x. Lees het symbool: een NVDA put met een strike van $200 die op 29 juni afloopt. Duizend dollar bij de eerste print kocht 1000 contracts; bij de laatste print was de positie gemarkeerd op $495000. NVDA daalde in de tweede helft van juni — deze diepe daling bevat de daling, sessie voor sessie — en dit contract was die daling, met leverage. Het vooraf weten is het deel dat geen enkele tabel kan verkopen; de eerste print zelf vindt u in de onderstaande analyse.

Wie staat er nog meer op de ranglijst

Alle vijf de contracts zijn puts — de is_put kolom is het bewijs — en zelfs de kleinste multiple was meer dan tien keer de inleg. Rij twee, een AAPL put met een strike van $240 die op 24 juli afloopt, ging van $0.01 naar $0.34 voor een 34x en was aan het einde van de maand nog actief (een juli-expiratie maakt die laatste prijs een marktprijs, geen settlement). Rij drie, een MU put met een strike van $100 die op 10 juli afloopt, leverde een 20x op en liep ook door in juli. Rij vier en vijf, een TSLA put met een strike van $397.50 en een QQQ put met een strike van $707, beide met een expiratie op 10 juni, leverden 12.5x en 11.7x op door de daling aan het begin van de maand. Vijf contracts, vijf weddenschappen op een daling.

Verkoop: hoe duizend dollar een verlies van een half miljoen wordt

Het kopen van de winnaar bracht een risico van exact duizend dollar met zich mee. Het VERKOOPEN ervan — waarbij diezelfde duizend dollar als premium wordt geïncasseerd — bracht de koersbeweging als risico met zich mee. De sold_net_loss_usd kolom toont elke regel vanuit het perspectief van de verkoper, waarbij margin, assignment en gedwongen buy-ins buiten beschouwing worden gelaten. De verkoop van 1000 contracten tegen $0.01 leverde duizend dollar op; de laatste print gaf de positie aan op $495000 voor de verkoper — een netto verlies van $494,000. Het slechtste scenario voor de koper is de ticketprijs; het slechtste scenario voor de verkoper is de koersbeweging, en de grootste beweging in juni bedroeg vijfhonderd tickets.

Het penny print-probleem

Waar komt de 495x vandaan? Het onderstaande overzicht comprimeert de volledige June tape van de winnaar in één forensische rij: de eerste print, de tweede print en een inventarisatie van elke penny print gedurende de gehele looptijd.

SELECT
    toString(toDate(min(sip_timestamp))) AS first_print_date,
    formatDateTime(toTimeZone(min(sip_timestamp), 'America/New_York'), '%H:%i:%S') AS first_print_et,
    round(anyIf(price, rn = 1), 2) AS first_price,
    toUInt64(anyIf(size, rn = 1)) AS first_print_contracts,
    countIf(price <= 0.011) AS penny_prints_in_june,
    toUInt64(sumIf(size, price <= 0.011)) AS penny_contracts_in_june,
    round(anyIf(price, rn = 2), 2) AS second_price,
    toUInt32(dateDiff('second', min(sip_timestamp), anyIf(sip_timestamp, rn = 2))) AS seconds_to_second_print,
    round(argMax(price, (sip_timestamp, price)), 2) AS month_last_price,
    round(argMax(price, (sip_timestamp, price)) / anyIf(price, rn = 2), 1) AS second_print_multiple_to_last,
    round(floor(1000 / (anyIf(price, rn = 2) * 100)) * argMax(price, (sip_timestamp, price)) * 100, 0) AS thousand_at_second_print_end_usd
FROM (
    SELECT sip_timestamp, toFloat64(price) AS price, size,
        row_number() OVER (ORDER BY sip_timestamp, price) AS rn
    FROM global_markets.options_trades
    WHERE ticker = 'O:NVDA260629P00200000'
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
)

Het contract bestond nog niet op de June tape tot 2026-06-15. De eerste print, om 09:49:30 ET, was 2 contracts tegen $0.01 — ongeveer twee dollar aan premium. De volgende print, 101 seconden later, was $2.44, waarna de penny nooit meer werd geprint (1 penny print, 2 contracts, de hele maand). De positie van duizend contracts waar de kop naar verwijst, is vijfmaal zo groot als de omvang die ooit tegen die prijs werd verhandeld. Als men bij de tweede print instapt, is een positie van duizend dollar tegen de laatste print van de maand $1980 waard — een 2x, geen 495x. De beweging vanaf de tweede print — een verdubbeling in twee weken via een volatiele koers — was reëel en verhandelbaar. De jackpot, zoals geprint, was dat niet.

Het verloop: tien sessies van beursnotering tot expiratie

Stel dat de onmogelijke order toch wordt uitgevoerd en houd vast tot het einde: elke sessie waarin het ticket werd verhandeld — turnover, de laatste prijs en de marktprijs van de positie.

WITH (
    SELECT (ticker, first_px)
    FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
    )
    ORDER BY last_px / first_px DESC, ticker ASC
    LIMIT 1
) AS winner
SELECT toDate(sip_timestamp) AS date,
    toUInt64(sum(size)) AS contracts_traded,
    round(sum(toFloat64(price) * toFloat64(size)) * 100 / 1e6, 2) AS day_premium_usd_m,
    round(toFloat64(argMax(price, (sip_timestamp, price))), 2) AS day_last_price,
    round(floor(1000 / (winner.2 * 100)) * toFloat64(argMax(price, (sip_timestamp, price))) * 100, 0) AS position_value_usd,
    round(100 * toFloat64(argMax(price, (sip_timestamp, price))) / max(toFloat64(argMax(price, (sip_timestamp, price)))) OVER (), 1) AS pct_of_peak
FROM global_markets.options_trades
WHERE ticker = winner.1
  AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY date
ORDER BY date ASC

Het contract werd verhandeld op alle 10 sessies van de looptijd, van 2026-06-15 tot expiratie op 2026-06-29. De eerste dag eindigde op $1.4, waarbij de duizend dollar al was genoteerd op $140000 onder de instapprijs. Daarna keerde de trend: een marktprijs van $287000 op 2026-06-17 kromp naar $106000 tegen 2026-06-22, een drawdown van bijna twee derde. Het hoogtepunt, $745000, werd bereikt op 2026-06-26, één sessie voor expiratie; de laatste prijs was $495000 — 66.4% van het hoogtepunt. Zelfs de beste trade van de maand eindigde een derde onder het eigen hoogtepunt. Turnover: op de eerste dag werden gedurende de hele sessie 385 contracts verhandeld — ongeveer de veronderstelde positie over de eerste drie sessies gecombineerd — terwijl de drukste dag, 2026-06-23, 9718 contracts en $2.86 miljoen aan premium realiseerde. De omvang nam pas toe nadat de beweging was ingezet.

De andere kant van de balans

SELECT
    count() AS contracts_with_50_trades,
    countIf(substring(ticker, -9, 1) = 'P') AS put_contracts,
    countIf(last_px / first_px >= 100) AS up_100x_plus,
    countIf(last_px / first_px >= 10) AS up_10x_plus,
    countIf(last_px / first_px >= 10 AND substring(ticker, -9, 1) = 'P') AS up_10x_puts,
    countIf(last_px / first_px >= 10 AND substring(ticker, -9, 1) = 'C') AS up_10x_calls,
    countIf(last_px / first_px <= 0.1) AS down_90_pct_plus,
    countIf(last_px / first_px <= 0.1 AND substring(ticker, -9, 1) = 'C') AS down_90_calls,
    round(100.0 * countIf(last_px / first_px <= 0.1 AND substring(ticker, -9, 1) = 'C') / countIf(last_px / first_px <= 0.1), 1) AS down_90_call_share_pct,
    countIf(last_px <= 0.02) AS ended_at_two_cents_or_less
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)

SELECT ticker AS contract,
    round(first_px, 2) AS first_price,
    round(last_px, 2) AS last_price,
    toUInt32(floor(1000 / (first_px * 100))) AS contracts_a_thousand_bought,
    round(floor(1000 / (first_px * 100)) * last_px * 100, 0) AS ending_value_usd
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
WHERE last_px <= 0.02 AND floor(1000 / (first_px * 100)) >= 1
ORDER BY first_px DESC, contract ASC
LIMIT 1

Het getal dat naast de jackpot hoort: van 30951 liquide contracten leverde precies 1 een honderdvoudige winst op — en 9385 leed een verlies van negentig procent of meer, waarbij 8949 contracten in het volledige universum voor het laatst voor twee cent of minder stonden. Bij een willekeurige selectie uit deze set kwam de groep met negentig procent verlies duizenden keren voor op elke jackpot. De duurste weg naar beneden: O:MU260612C01350000, een MU call met een strike van $1.350 die op 12 juni afloopt, begon in juni op $10 en eindigde op $0.01, waardoor duizend dollar veranderde in $1.

Calls of puts: welke zijde won?

De twee uitersten komen niet overeen. De winnende zijde bestond volledig uit puts: elke 14 ten-bagger was een put (14 puts, 0 calls) in een universum met 14994 puts onder 30951 contracten. De verliezende zijde was bijna gelijk verdeeld: van de 9385 bijna-totale verliezen waren 4403 — 46.9% — calls, waarbij puts een lichte meerderheid vormden. De richting bepaalde elke grote winnaar, maar redde op zichzelf niemand: duizenden puts belandden ook in de groep met verliezen, door een verkeerde strike, een verkeerde week, of beide.

Waar de verliezen zich ophapten

Welke onderliggende waarde zorgde voor de begraafplaats? Niet de naam van de crash.

SELECT
    multiIf(startsWith(ticker, 'O:NVDA'), 'NVDA', startsWith(ticker, 'O:TSLA'), 'TSLA', startsWith(ticker, 'O:AAPL'), 'AAPL', startsWith(ticker, 'O:SPY'), 'SPY', startsWith(ticker, 'O:QQQ'), 'QQQ', 'MU') AS root,
    count() AS contracts,
    countIf(last_px / first_px <= 0.1) AS down_90_pct_plus,
    round(100.0 * countIf(last_px / first_px <= 0.1) / count(), 1) AS pct_of_root_wiped,
    round(100.0 * countIf(last_px / first_px <= 0.1) / sum(countIf(last_px / first_px <= 0.1)) OVER (), 1) AS share_of_all_down_90_pct,
    countIf(last_px / first_px >= 10) AS up_10x_plus
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
GROUP BY root
ORDER BY down_90_pct_plus DESC, root ASC

QQQ leverde de grootste groep: 2923 bijna-totale verliezen — 31.1% van de totale groep — waarbij 35.7% van de liquide contracten volledig waardeloos werd. Tel de 24.7% van SPY erbij op en de index-roots vormen meer dan de helft van de begraafplaats. De twee laagste wipe rates behoren toe aan NVDA en AAPL (21.8% en 21.8%) — de eerste hiervan is NVDA, de root achter de grootste winnaar van de maand. De groep groeide het sterkst waar de premium ongewijzigd bleef. De andere kant, op dezelfde tabel: QQQ produceerde 9 van de 14 ten-baggers van de maand; SPY, met 2319 contracten in de groep, produceerde 0.

Wat deze tabel laat zien (en wat niet)

Vier lessen. Convexity is reëel: een goedkope out-of-the-money optie stijgt absurd hard wanneer de onderliggende waarde snel beweegt — precies de reden waarom loterijtickets voor centen worden verhandeld. Headline multiples vereisen forensisch onderzoek: de 495x van juni is gebaseerd op één transactie van twee lots; de verhandelbare beweging was een verdubbeling. De distributie is de prijs voor convexity: 14 ten-baggers staan naast 9385 bijna-totale verliezen (de uitleg over market makers behandelt wie de tickets verkoopt). En achterafkijken is niet verhandelbaar: het winnende ticket bestond nog niet op 1 juni — het werd pas op 15 juni genoteerd — en de aankoop ervan zou betekenen dat men die ochtend de richting en timing van de daaropvolgende twee weken kende. Deze pagina meet wat juni bevatte. Het geeft geen indicatie van wat juli zal bevatten.

FAQ

Wat was de beste optietrade van juni 2026?

Gemeten van de eerste print naar de laatste over zes liquide roots, was een NVDA put met een strike van $200 die op 29 juni 2026 afloopt: $0.01 tot $4.95, een 495x multiple — gebaseerd op een penny first print van twee lots (de volgende print was $2.44).

Kun je meer verliezen dan je investeert bij het handelen in opties?

Bij het kopen van opties niet: een koper kan maximaal de betaalde premium verliezen. Bij het verkopen van opties wel — de gegevens van juni tonen een verkoper die duizend dollar aan premium incasseerde en eindigde met $494,000 underwater bij de laatste print.

Waarom verlopen de meeste goedkope opties waardeloos?

Een goedkope optie prijst een uitkomst die de markt onwaarschijnlijk acht: een grote beweging vlak voor een naderende deadline. De meeste maanden leveren weinig van dergelijke bewegingen op, waardoor de meeste tickets decay vertonen. In juni 2026 verloor 9385 van 30951 actief verhandelde contracts ten minste negentig procent van hun eerste printwaarde; 8949 handelde voor het laatst tegen twee cents of minder.

Had een echte trader de 495x kunnen pakken?

Bijna zeker niet bij de geprinte omvang: slechts 2 contracts werden ooit verhandeld tegen de $0.01 entry, en de prijs stond op $2.44 binnen 101 seconden. Duizend dollar bij de tweede print was ongeveer $1980 tegen de laatste print — een sterke trade, een levensveranderende multiple alleen met terugwerkende kracht.

Databemerkingen

Methodologie

• Periode: 1–30 juni 2026; tijdstempels zijn opgeslagen in UTC en gefilterd met ruwe UTC-grenzen. Het kalibratiepaneel is de basisblok en kijkt doelbewust terug over 2026, op identieke wijze berekend.
• Per contract: eerste prijs = de vroegste transactie van de SIP-tijdstempel in juni, laatste = de laatste; gelijke waarden worden deterministisch opgelost door prijs. Bij meerdere waarden geldt de laatste boven de eerste, berekend in de query.
• Het daily-path paneel herleidt de winnaar uit dezelfde gerangschikte scan bij elke generatie; het entry receipt legt dit vast per symbool, met grenzen die de positie behouden als deze verschillen.
• Generatie vindt uitsluitend plaats in batches via het gated read-only pad; de pagina voert nooit live queries uit. Warehouse-status per 12 juli 2026.

Elk paneel is één opgeslagen object — grafiek, tabel en SQL. Raadpleeg het grootboek zelf via de Strasmore terminal.