
<p class="has-drop-cap">1 Marcus Melander fick sin efterlängtade seger i Hambletonian i lördags och loppet blev en minnesvärd duell mellan två svensktränade treåringar som vägrade ge sig över Meadowlands upplopp.</p>



<p>Segertiden för <strong>Apex</strong> (e. Walner), 1.08,0a/1.609 meter, är den näst snabbaste noteringen av en treårig travare och bara Åke Svanstedts <strong>Six Pack</strong> (e. Muscle Mass) har travat snabbare. Six Pack sprang 1.07,9a/1.609 meter vid segern i Kentucky Futurity 2018 och han är därmed den enda treåriga travaren som underskridit 1.08,0.</p>



<p>Luc Blais <strong>Emoticon Legacy</strong> (e. Walner) vann Kentucky Futurity på 1.08,0a/1.609 meter ifjol och delar därmed andraplatsen i listan över världens snabbaste treåringar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/emoticanlegacylrm251005adamstromstalltz-617x410.jpg" alt="" class="wp-image-776170"/><figcaption class="wp-element-caption">Emoticon Legacy tar hem Kentucky Futurity för Louis-Philippe Roy. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Tiderna 1.08,1 och 1.08,2 har ett gäng treåriga travare tangerat vid ett flertal tillfällen och det är faktiskt gott om svensktränade hästar som lyckats peta sig in på topplistan. Apex är alltså den senaste.</p>



<h2 class="wp-block-heading">Världens snabbaste treåringar</h2>



<p><em>Namn (kön/far) – Bana – År – Segertid</em></p>



<ul class="wp-block-list">
<li><strong>Six Pack</strong> (h e. Muscle Mass) – Red Mile –  2018 – 1.07,9</li>



<li><strong>Emoticon Legacy</strong> (h e. Walner) – Red Mile – 2025 – 1.08,0</li>



<li><strong>Apex</strong> (h e. Walner) – Meadowlands – 2026 – 1.08,0</li>



<li><strong>Dancingintthedark M</strong> (h e. Readly Express) – Red Mile – 2021 – 1.08,1</li>



<li><strong>Jujubee</strong> (h e. Creatine) – Red Mile – 2021 – 1.08,1</li>



<li><strong>Sig Sauer</strong> (h e. Muscle Hill) – Red Mile – 2024 – 1.08,1</li>



<li><strong>Go Dog Go</strong> (h e. Greenshoe) – Red Mile – 2025 – 1.08,1</li>



<li><strong>Plunge Blue Chip</strong> (s e. Muscle Mass) – Meadowlands – 2018 – 1.08,2</li>



<li><strong>Plunge Blue Chip</strong> (s e. Muscle Mass) – Red Mile – 2018 – 1.08,2</li>



<li><strong>Impinkintoo</strong> (s e. Manofmanymissions) – Red Mile – 2018 – 1.08,2</li>



<li><strong>Greenshoe</strong> (h e. Father Patrick) – Red Mile – 2019 – 1.08,2</li>



<li><strong>Jujubee</strong> (h e. Creatine) – Meadowlands – 2021 – 1.08,2</li>



<li><strong>Rebuff</strong> (h e. Muscle Hill) – Meadowlands – 2022 – 1.08,2</li>



<li><strong>Emoticon Legacy</strong> (h e. Walner) – Mohawk – 2025 – 1.08,2</li>
</ul>



<p><strong>Marcus Melander</strong> har tränat/tränar Apex, Dancinginthedark M och Greenshoe.<br><strong>Åke Svanstedt</strong> tränade Six Pack och Plunge Blue Chip.<br><strong>Lucas Wallin</strong> tränade Rebuff.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">2 Och när vi ändå är inne på rekord. Marcus Melanders lördag på Meadowlands lär bli kvar i hans minne livet ut, inte bara för att Apex vann Hambletonian, utan hela tävlingsdagen blev en enda lång framgångssaga där totalt 1.164.452 amerikanska dollar kördes in till stallet. </p>



<p>Med dagens valutakurs omvandlas den summan till <strong>11.161.875 kronor</strong>, vilket man tycker skulle kunna vara något slags rekord på en och samma tävlingsdag, men så är inte fallet. Faktum är att både Jimmy Takter och Åke Svanstedt varit värre på nordamerikansk mark. Jimmy Takters Breeders Crown-dag på Woodbine i oktober 2015 var smått osannolik med sex vinnare och totalt <strong>2.077.487</strong> amerikanska dollar inkört.</p>



<p>I den summan inkluderas även fyra passgångarlopp, av vilka Takter vann två. <strong>Pure Country </strong>vann de tvååriga stonas BC-final och tjänade 389.220 kanadensiska dollar medan <strong>Always B Miki</strong> vann den öppna avdelningen för hingstar och valacker, en vinst som gav 259.480 kanadensiska dollar in på kontot.</p>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2017/03/wildhoneyhuvmia-617x346.jpg" alt="Wild Honey. Foto Mia Törnberg" class="wp-image-3636" style="width:365px;height:auto"/><figcaption class="wp-element-caption">Wild Honey. Foto Mia Törnberg</figcaption></figure>



<p>Takters vinnare bland travarna den lördagen var <strong>All The Time</strong> (e. Muscle Hill) i de tvååriga stonas avdelning (C$389.220), <strong>Wild Honey</strong> (e. Cantab Hall) i de treåriga stonas lopp (C$324.350), <strong>The Bank</strong> (e. Donato Hanover) i de treåriga hingstarna och valackernas division (C$324.350) och <strong>Creatine</strong> (e. Andover Hall) i den öppna klassen för hingstar och valacker (C$344.622).</p>



<p>Jimmy Takters hästar sprang alltså in 2.077.487 dollar samma dag och det är ett svårslaget rekord som lär stå sig ett bra tag framöver.</p>



<p>Men Åke Svanstedt har en hygglig dag på jobbet att se tillbaka på han också. I oktober 2023, också det i samband med Breeders Crown-finalerna, körde stall Svanstedt in <strong>1.189.000</strong> amerikanska dollar på Hoosier Park i Indiana.</p>



<p><strong>Warrawee Michelle</strong> (e. Walner) vann sin avdelning för de tvååriga stona kvällen innan rekorddagen för Svanstedt, men i och för sig innebar segern med det då tvååriga stoet att Åke Svanstedt nådde en annan milstolpe, nämligen en miljard kronor inkört under hela travtränarkarriären.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2022/10/jiggyjogs2022breederscrown1024px-617x348.jpg" alt="" class="wp-image-374411" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Svenskfödda och Åke Svanstedt-tränade Jiggy Jog vid segern i Breeders Crown-finalen för Dexter Dunn. Foto: New Image Media</figcaption></figure>



<p><strong>Jiggy Jog</strong> (e. Walner) för äldre ston, <strong>Bond</strong> (e. Southwind Frank) i loppet för treåriga ston och <strong>Southwind Tyrion</strong> (e. Muscle Hill) när de äldre hingstarna och valackerna möttes var de vinnare som Svanstedt kunde räkna in på Hoosier Park 2023.</p>



<p>Marcus Melanders vinnare under lördagen på Meadowlands var förutom Apex, <strong>Nezudo Kamado</strong> (e. Chapter Seven) i Oaks, <strong>Super Chapter</strong> (e. Chapter Seven) i John Cashman Memorial och <strong>Bourbonista</strong> (e. Face Time Bourbon) i Vincennes.</p>



<p>På svensk mark har Timo Nurmos rekordet gällande vinstrikast under en och samma tävlingsdag. Den 14 oktober 2023 vann Nurmos först Oaks med <strong>Adriatica</strong> (e. Bold Eagle), en seger värd 3.000.000 kronor och sedan fyllde han på i kassan genom <strong>Fame And Glory</strong>s (e. Tactical Landing) triumf i Kriteriet, värd 4.000.000 kronor. Måltrean <strong>Our Pride</strong> (e. Maharajah) tjänade en miljon kronor och sexan <strong>Nouri di Quattro</strong> (e. Southwind Frank) fick 200.000 kronor.</p>



<p>8.559.000 kronor tjänade Timo Nurmos hästar den lördagen och det är rekordnoteringen för en tränare på svensk mark.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3 Från osåld till 700.000 kronor. Spännvidden är stor när det gäller auktionspriserna som ettåringar för hästarna i tre avdelningar i Sweden International Yearling Sales Auktionslopp på Solvalla ikväll.</p>



<p>Två hästar kostade 700.000 kronor när de bytte ägare som ettåringar: Hingsten <strong>Napoleon Journey</strong> (e. Bar Hopping), som väntar på första segern efter sex försök, och stoet <strong>Natural Boko</strong> (e. Readly Express) med en seger i bagaget.</p>



<p>Det största namnet bland stona är Björn Goops <strong>Thai Medina</strong> (e. Face Time Bourbon), som är tillbaka på banan efter att ha vunnit långa E3-finalen på Bergsåker för drygt en månad sedan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/thaimedinabgadam-617x333.jpg" alt="" class="wp-image-867471"/><figcaption class="wp-element-caption">Thai Medina och Björn Goop. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p>Bland hingstarna sticker två miljonärer ut, som båda hade starka tvååringssäsonger. Joakim Elfving tränar Svampen-vinnaren <strong>City Slicker</strong> (e. King City), som följts upp med tredjeplatsen i långa E3 i sommar, medan Claes Sjöström mönstrar <strong>Neutron Star</strong> (e. Gimpanzee), tvåa i Svensk Uppfödningslöpning förra året.</p>



<p>Auktionsloppen är öppna för hästar som varit anmälda till Yearling Sales auktioner 2024. Hingstarna och valackerna tävlar i ett lopp med 300.000 kronor i förstapris, medan intresset på stosidan var större och loppet delades i två avdelningar med 150.000 kronor till vinnarna.</p>



<h2 class="wp-block-heading">Så mycket kostade hästarna i auktionsloppen:</h2>



<p><strong>Hingstar/valacker</strong></p>



<p>Häst (far) – Auktion – Auktionspris (kr)</p>



<ul class="wp-block-list">
<li>Napoleon Journey (e. Bar Hopping) – Solvalla – 700.000 kr</li>



<li>Neutron Star (e. Gimpanzee) – Solvalla – 480.000 kr</li>



<li>No Quit (e. Gimpanzee) – Solvalla – 260.000 kr</li>



<li>Rockabilly Artist (e. Father Patrick) – Solvalla – 220.000 kr</li>



<li>Willy Rapid (e. Readly Express) – Åby – 220.000 kr</li>



<li>Vulcan Tile (e. Father Patrick) – Åby – 160.000 kr</li>



<li>Outer Space (e. Nuncio) – Solvalla – 150.000 kr</li>



<li>Yardbird (e. Bird Parker) – Criterium – 150.000 kr</li>



<li>City Slicker (e. King City) – Criterium – 40.000 kr</li>



<li>Long Night Out (e. Bar Hopping) – Solvalla – osåld</li>
</ul>



<p><strong>Ston</strong></p>



<p>Häst (far) – Auktion – Auktionspris (kr)</p>



<ul class="wp-block-list">
<li>Natural Boko (e. Readly Express) – Solvalla – 700.000 kr</li>



<li>Tundra Håleryd (e. Fourth Dimension) – Åby – 480.000 kr</li>



<li>Seventh Avenue (e. Calgary Games) – Solvalla – 400.000 kr</li>



<li>Exquisite Scotch (e. Calgary Games) – Solvalla – 360.000 kr</li>



<li>Navy Cut (e. Greenshoe) – Solvalla – 320.000 kr</li>



<li>Thai Medina (e. Face Time Bourbon) – Solvalla – 300.000 kr</li>



<li>Dreamlike Jog (e. Bold Eagle) – Solvalla – 280.000 kr</li>



<li>Sirius Mimmi (e. Father Patrick) – Solvalla – 190.000 kr</li>



<li>Trendy Zon (e. Maharajah) – Solvalla – 180.000 kr</li>



<li>Hot lips Art (e. Googoo Gaagaa) – Åby – 150.000 kr</li>



<li>Pure Brilliance (e. Brillantissime) – Solvalla – 150.000 kr</li>



<li>Pure Phoenix (e. Bird Parker) – Solvalla – 150.000 kr</li>



<li>Graffiti Brodda (e. Readly Express) – Åby – 140.000 kr</li>



<li>Abundance (e. Maharajah) – Criterium – 120.000 kr</li>



<li>Wolga (e. Maharajah) – Åby – 80.000 kr</li>



<li>Donna Gold (e. Don Fanucci Zet) – Criterium – 60.000 kr</li>
</ul>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4 På <strong>Solvalla</strong> (första start 17.55) väntar årets andra tvååringslopp på svensk mark och totalt ska ett 80-tal lopp för de yngsta köras i Sverige i år.</p>



<p>Nio hästar har anmält sitt intresse på Solvalla och bland fäderna finns en debuthingst med sin första startande avkomma. USA-födde <strong>Damien</strong> (e. Muscle Hill-Danae), 1.14,9am*/96.500 kronor, är helbror till självaste Propulsion, men det blev bara fyra starter varav tre slutade med seger.</p>



<p>I första kullen finns tolv tvååringar, där <strong>Easeurbrainfreeze</strong> ska försöka hålla pappa Damiens fana högt. Visbyamatören Johan Franzén tränar och kör tvååringen. </p>



<p>Första tvååringsvinnaren i Sverige var Skellefteå-amatören Lage Berglunds sto <strong>Jumbled Story</strong> (e. Calgary Games), som travade 1.17,9/1.640 meter vid sin överlägsna seger i Boden i torsdags tillsammans med Leif Eriksson.</p>



<p>I övrigt på Solvalla dyker Mattias Djuses ämne <strong>Com Best </strong>(e. Tactical Landing) upp. Treåringen har inlett fläckfritt med två segrar på lika många starter och travade 1.13,9am vid andra vinsten.</p>



<p>Com Best lär bli hårt anlitad på V64-spelet där det väntar en riktigt stor sexrättspott. Det är jackpot och över fem miljoner kronor extra ligger redan i högsta vinstpoolen sedan ingen lyckats pricka alla sex vinnare i Kalmars jackpotomgång i fredags.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">5 Travveckan inleds på veckans huvudbana. <strong>Åby</strong> (första start 12.20) värmer upp inför lördagens storloppsdag med Åby Stora Pris genom att köra lunchtävlingar idag.</p>



<p>Dit reser Per Lennartsson för att agera gästkusk åt avstängde Robert Bergh och Per kör fem hästar. Duon har firat framgångar tidigare när Lennartsson – som när Bergh-tränade Hail Mary (e. Googoo Gaagaa) vann Breeders Crown-finalen för fyraåriga hingstar och valacker 2020 med Lennartsson i lånesits.</p>



<p>Igår värmde Lennartsson och Bergh upp i Åmål när Per vann med Åbytränarens segermaskin Nickel Occagnes (e. Titan d’Occagnes), som tog elfte segern på 22 försök.</p>



<p>Bland dagens uppsittningar finns treårige <strong>Omark</strong> (e. Chelsea Boko), som vunnit sitt enda felfria lopp på tre försök hittills. Hästen har en sylvass syskonskara att leva upp till: Indi Boko (6,1 miljoner), Amaru Boko (4,3), Grand Boko (2,7) och Peggy Boko (1,2).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/08/260810.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till måndagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6 En av Hambletonian-fältets mer betrodda hästar i lördags var Chris Beavers <strong>Endurance</strong> (e. Captain Corey), som galopperade med tätkänning i utgången av slutkurvan. </p>



<p>Beaver uttalade sig om Endurance tillstånd i sociala medier under söndagen och det är ingen munter läsning. Captain Corey-sonen lär inte komma tillbaka till tävlingsbanan mer i år.</p>



<p><strong>Beaver berättade följande:<br></strong>”<em>Tyvärr drabbades Endurance av en fraktur i hovbenet i gårdagens Hambletonian. Han kommer att återhämta sig, men det kommer att ta tid. Trots allt han har åstadkommit tror jag aldrig att vi fick se hans verkliga potential.</em></p>



<p><em>Jag vill tacka mina delägare för deras stöd i både med- och motgång och alla de människor som har hört av sig och visat sitt stöd under de senaste veckorna</em>.”</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/barontillycjjgk-617x333.jpg" alt="" class="wp-image-558887"/><figcaption class="wp-element-caption">David Persson-tränade Baron Tilly. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">7 Folkkäre Leif &#8221;Loket&#8221; Olsson ska hedras på Åby på lördag och snabbloppet i hans minne, som är öppet för hästar som tjänat mellan 500.001 och 3.500.000 kronor, har lockat några spännande hästar till start. </p>



<p>Det är kort distans som gäller och mest spänd är kanske publiken på David Perssons <strong>Baron Tilly</strong> (e. Ready Cash), som kommer till start med en etta och en tvåa högst upp i resultatraden. Tvåan är från Harper Hanovers lopp på Solvalla i maj där sexåringen tjänade en halv miljon kronor, men efter det har det krånglat och nu återgår David Persson till den distans som Baron Tilly faktiskt vunnit över i år. </p>



<p>1.09,6a/1.640 meter travade Baron Tilly i årsdebuten på Färjestad och på lördag stöter han ihop med hästar som <strong>Eldorado Jet</strong> (e. Twister Bi), <strong>Boscha Diablo</strong> (e. Traders), <strong>Caviar From Mine </strong>(e. S.J.&#8217;s Caviar) och <strong>Jerka Sting</strong> (e. Readly Express) när 200.000 kronor väntar vinnaren.</p>



<p>Ragnar Thorngrens Minne för fyraåringar blev en tunn historia med bara sju hästar till start. 200.000 kronor står på spel för vinnaren även här och distansen är 2.140 meter. Daniel Redéns kanadick <strong>Chat Room</strong> (e. Chapter Seven) imponerade som trea efter markförlust i Prix Cagnes-sur-Mer på Jägersro under Åbergs-kvällen och valacken är den mest meriterade fyraåringen bland de sju deltagarna.</p>



<p>André Eklundhs Drottningpokalvinnare <strong>Panthere d&#8217;Inverne</strong> (e. Brillantissime) jagar första segern som femåring och den kan mycket väl komma i Bertil Knutssons Minne, tillika diamantstoets andra försök i aktuellt STL-meeting.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/05/pantheredinverneaem250503adamstromstalltz-617x368.jpg" alt="" class="wp-image-714729" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Panthere d&#8217;Inverne och André Eklundh vid segern i Drottning Silvias Pokal ifjol. Foto: Adam Ström/stalltz.se<br></figcaption></figure>



<p>Panthere d&#8217;Inverne har gjort tre starter 2026 med en andraplats på Axevalla i senaste starten att ta med sig till lördagens uppgift. Stefan Persson kör det femåriga stoet i loppet som erbjuder 200.000 kronor till vinnaren.</p>
