Strasmore Research
Deep Dives · 2026-07-04

The Best and Worst Thousand Dollars of June 2026

The single best options contract of June returned 495x — and sat beside thousands of near-total losses. The full hindsight ledger, receipts included. Not advice.

What was the single best options trade of June 2026 — and what would a thousand dollars in it have become? This page answers that question honestly, which means answering it twice: once with the jackpot, and once with the nine thousand near-total losses that surrounded it. Everything here is computed AFTER the fact from the stored tape. Nobody picked these trades in advance, including us; a hindsight-optimal trade is a measurement of what the month contained, not a strategy. Every number is a stored query result; expand any panel for the exact SQL.

The month's biggest multiples

The universe: every options contract on six of the tape's most liquid roots with at least fifty June trades — 30951 contracts. For each, the first June print against the last.

QueryThe five biggest first-print-to-last-print multiples of June (six liquid roots, 50+ trades)
The exact SQL behind every number
SELECT ticker AS contract,
    round(first_px, 2) AS first_price,
    round(last_px, 2) AS last_price,
    round(last_px / first_px, 1) AS multiple,
    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
QueryThe winning ticket, in full: what a thousand dollars at the first print became at the last
The exact SQL behind every number
SELECT ticker AS contract,
    round(first_px, 2) AS first_price,
    round(last_px, 2) AS last_price,
    round(last_px / first_px, 0) AS multiple,
    toUInt32(floor(1000 / (first_px * 100))) AS contracts_bought,
    round(floor(1000 / (first_px * 100)) * last_px * 100, 0) AS ending_value_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 last_px / first_px DESC, contract ASC
LIMIT 1

The winner was a put: O:NVDA260629P00200000, first printed at $0.01 and last printed at $4.95 — a 495x multiple. A thousand dollars at the first print bought 1000 contracts; at the last print the position marked at $495000. Read the symbol: it is a $200-strike NVDA put expiring June 29 — a bet, placed as the month opened, that NVDA would fall hard within four weeks. NVDA then fell through the month (its deep-dive has the slide, session by session). Knowing that in advance is the part no table can sell you.

The other side of the ledger

QueryThe full distribution: for every jackpot, thousands of near-total losses
The exact SQL behind every number
SELECT
    count() AS contracts_with_50_trades,
    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 <= 0.1) AS down_90_pct_plus,
    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
    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
)
QueryThe most expensive ticket to zero: the priciest contract that ended at two cents or less
The exact SQL behind every number
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
    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 AND toFloat64(argMax(price, (sip_timestamp, price))) <= 0.02
      AND floor(1000 / (toFloat64(argMin(price, (sip_timestamp, price))) * 100)) >= 1
)
ORDER BY first_px DESC, contract ASC
LIMIT 1

Here is the number that belongs next to the jackpot: of 30951 liquid contracts, exactly 1 returned a hundredfold — and 9385 lost ninety percent or more, with 8949 last printing at two cents or less. Drawing blind from this deck, the ninety-percent-loss pile was drawn thousands of times for every jackpot. The worst thousand dollars had plenty of candidates; the receipt above shows the most expensive route — O:MU260612C01350000 opened June at $10 and finished at $0.01, turning a thousand dollars into $1.

What this table teaches (and what it can't)

Three honest lessons live in these panels. First, convexity is real: a cheap out-of-the-money option can multiply absurdly when the underlying moves fast, which is exactly why lottery-ticket contracts trade at a penny. Second, the distribution is the price of that convexity: the 14 contracts that went ten-x-plus sit beside 9385 that were nearly wiped out — the expected outcome of buying pennies is losing them (the market makers explainer covers who sells the lottery tickets). Third, hindsight tables cannot be traded: the winning ticket required knowing, on June 1, both the direction and the timing of a twenty-percent-range month. This page measures what June contained. It does not suggest what July will.

The session receipt

Query21 option sessions in the month
The exact SQL behind every number
SELECT uniqExact(toDate(sip_timestamp)) AS june_sessions
FROM global_markets.options_trades
WHERE startsWith(ticker, 'O:SPY') AND length(ticker) = 20
  AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)

Data notes

Full data notes
  • Hindsight, not advice. Every figure is computed after the fact from stored trades. Selecting these contracts in advance required information nobody had. Strasmore publishes measurements, not recommendations.
  • "First print to last print" is a measuring stick, not an execution report. It assumes buying at the month's first traded price and marking at the last — real fills, especially a thousand contracts at one cent, would face size, spread, and availability constraints this table does not model. That caveat cuts both ways and is why the numbers are labeled multiples, not returns.
  • Universe: contracts on six liquid roots (MU, NVDA, TSLA, SPY, QQQ, AAPL — standard OCC symbols only, adjusted contracts excluded by symbol length) with ≥50 June trades and a nonzero first print. Widening the universe would mostly add thinner contracts and more zeroes.
  • Expiry/strike/type are parsed from the OCC symbol; premium math assumes the 100-share multiplier.

Methodology

  • Period: June 1–30, 2026. Timestamps stored UTC, filtered with raw UTC bounds.
  • Per contract: first price = the June trade with the earliest SIP timestamp; last price = the latest. Simultaneous prints (identical nanosecond stamps) are tie-broken deterministically by price, so regeneration always reproduces the same figures. Multiples are last over first, computed in-query.
  • Generation is batch-only through the gated read-only path; the public page never queries live. Warehouse state as of July 4, 2026.

Every panel is one stored object — chart, table, and SQL. Interrogate the ledger yourself on the Strasmore terminal.

#options#hindsight#convexity#risk#deepdive