
<p class="has-drop-cap">1 Breeders Crown-finaler för de tvååriga travarna (och passgångarna) väntar i kväll på Mohawk och extra spännande är det för flera av de svenska tränarna verksamma i Amerika då de har väl förspänt inför kvällens prestigefyllda löpningar.</p>



<p>Marcus Melanders <strong>Apex</strong> (e. Walner) blir, vid seger i Breeders Crown (C$959.000), dollarmiljonär som tvååring, något som inte tillhör vanligheterna bland travarna i Nordamerika. På Apexs konto finns inför finalen 821.575 dollar och prissumman i amerikanska dollar är 700.000, varav hälften går till vinnaren. Inför denna start har Apex kvalat på 1.11,0a/1.609 meter via 1.09,1 sista 400 meterna.</p>


<div class="factbox right minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Dollarmiljonärer som tvååring								</h3>
<div class="content">
<p>2007 <strong>Snow White</strong> $1.252.646<br />2009 <strong>Poof She’s Gone</strong> $1.037.099<br />2021 <strong>Venerable</strong> $1.039.966<br />2023 <strong>T C I </strong>$1.238.870, <strong>Karl</strong> $1.041.977<br />2024 <strong>Maryland</strong> $1.227.695</p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p>Totalt elva av de 20 finalisterna i Breeders Crown tränas av svenskar och det är väl också så att det i stonas avdelning ser upplagt ut för blågult. Jim Oscarssons <strong>Southwind Chaska</strong> (e. Tactical Landing) har visat sig tillhöra kulltoppen och kan från vettigt läge sluta i segerstriden. Jim Doherty-vinnaren <strong>Atlantic Summer</strong> (e. Captain Corey) var, precis som Apex (Peter Haughton Memorial), direktkvalificerad till Breeders Crown i och med den nyss nämnda segern och Ron Burke har luftat henne i ett kvallopp på Meadowlands inför kvällens final. Atlantic Summer travade då 1.13,3a/1.609 meter med en 1.10-avslutning sista 400 meterna.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/10/southwindchaskattm251004adamstromstalltz-617x394.jpg" alt="" class="wp-image-775899" style="width:435px;height:auto"/><figcaption class="wp-element-caption">Southwind Chaska vinner för Tim Tetrick. Foto: Adam Ström/stalltz.se</figcaption></figure>



<h2 class="wp-block-heading">Startlista Breeders Crown tvååriga ston ($700.000)</h2>



<p><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>Lainey W (e. Bar Hopping) – Marcus Melander</li>



<li>Nezuko Kamado S (e. Chapter Seven) – Marcus<strong> </strong>Melander</li>



<li>Southwind Chaska (e. Tactical Landing) – Jim Oscarsson</li>



<li>Atlantic Summer (e. Captain Corey) – Ron Burke</li>



<li>Storybook Love (e. Chapter Seven) – Matthew Bax</li>



<li>Bingo Night (e. Green Manalishi) – Dustin Jones</li>



<li>Sparks (e. Walner) – Åke Svanstedt</li>



<li>Wishuponastar Deo (e. Six Pack) – Susanne Kerwood</li>



<li>Setyoursightshigh (e. In Range) – Marcus Melander</li>



<li>R Ro (e. Chapter Seven) – John Butenschoen</li>
</ol>



<h2 class="wp-block-heading">Startlista Breeders Crown tvååriga hingstar och valacker ($700.000)</h2>



<p><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>Apex (e. Walner) – Marcus Melander</li>



<li>Spencer Hanover (e. Chapter Seven) – Marcus Melander</li>



<li>Diabolic Hill (e. Muscle Hill) – Anne Stoebe</li>



<li>Nix Nacken (e. Muscle Hill) – Marcus Melander</li>



<li>Land The Plane (e. Tactical Landing) – Carl Jamieson</li>



<li>Kingmen (e. Walner) – Per Engblom</li>



<li>L P Bay (e. Trixton) – Mark Etsell</li>



<li>Cambridge Hanover (e. Walner) – Andrew Harris</li>



<li>Im Kronos (e. Walner) – Åke Svanstedt</li>



<li>Mr Big Spender (e. Captain Corey) – Norm Parker</li>
</ol>



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



<p class="has-drop-cap">2 Fyra lopp med 100.000 kronor i förstapris. Bollnäs (första start 18.20) bjuder på finfina tävlingar denna höstkväll med finaler i tre-, fyra- och stoserien och ett snabblopp över sprinterdistans med startbil.</p>



<p>Långt innan Bollnästravet hade premiär i juli 1955 tävlade <strong>Anders Kilström </strong>med sina hästar på isen på den lilla sjön Vågen i centrala Bollnäs. Ikväll hedras Anders Kilström, som föddes 1894, med två minneslopp i form av unghästfinalerna.</p>



<p>Anders var pappa till travprofilerna Rune, Ivar och Börje där Ivar sedermera blev tränare på Solvalla. Idag lever familjens namn vidare på travbanorna via bland annat en viss Örjan Kihlström, son till Ivar och sonson till Anders Kilström.</p>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/05/2orjankihlstrom-617x333.jpg" alt="" class="wp-image-722954" style="width:442px;height:auto"/><figcaption class="wp-element-caption">Örjan Kihlström tävlar i Bollnäs idag. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Örjan är på plats i Bollnäs och kör fem lopp, däribland de fyra stora loppen. I högsta klassen sitter han upp bakom Daniel Wäjerstens <strong>Mellby Joker</strong> (e. Muscle Hill), som travade 1.09,0ak i Mikkeli i somras. Nu ställs han mot stallkamraten <strong>Global Badman</strong> (e. Yield Boko), <strong>Y.Not Diamant</strong> (e. Odessa Santana), fjolårets Sprintermästare <strong>Crown</strong> (e. Chapter Seven) – och framför allt Jan Ove Olsens gulddivisionsvinnaren just i Bollnäs för 1,5 månader sedan, <strong>Mizai</strong> (e. Donato Hanover).</p>



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



<p class="has-drop-cap">3 Det finns fler godbitar i Bollnäs, där snabbloppet för kallblod håller hög klass. Gunnar Melander plockar ut <strong>Månlykke A.M.</strong> (e. Månprinsen A.M.) och sitter för fjärde starten i rad själv i sulkyn. Jan-Olov Persson mönstrar flerfaldiga miljonärerna <strong>Oppgårdsdrängen</strong> (e. Tekno Odin) och <strong>B.W.Sture</strong> (e. Moe Odin), medan nybakade femman i Nordiskt Mästerskap, Nicklas Bloms <strong>Bäcklös Uriel</strong> (e. Smedheim Solan), jagar andra årssegern.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2020/08/manlykkea.m.heat-617x333.jpg" alt="" class="wp-image-108116" style="width:571px;height:auto"/><figcaption class="wp-element-caption">Månlykke A.M. och Gunnar Melander och Månlykke A.M. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2020/12/emilialeo-1-617x697.jpg" alt="" class="wp-image-124023" style="width:390px;height:auto"/><figcaption class="wp-element-caption">Emilia Leo. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Från Norge gästar tvåan och trean från just Nordiskt Mästerskap i finska Åbo för tre veckor sedan: segermaskinen <strong>Stumne Fyr</strong> (e. Joker Elden) och <strong>Grislefaksen G.L.</strong> (e. Järvsöfaks).</p>



<p>Sedan 2015 har forna hemmabanan Bollnäs lyft fram Jennifer Tillmans prestationer genom damloppet <strong>Jennifer Tillman Invitation</strong>. Jennifer är enda kvinnan som vunnit Elitloppsförsök – med Per  Eriksson-tränade <strong>Royal Fighter</strong> (e. Varenne) 2015 – och hon lämnade in körlicensen 2020 efter 455 segrar i karriären</p>



<p>Ikväll är det dags för årets upplaga. Tolv tjejer slåss om segern och ett hederspris i form av Jennifer Tillmans travsmycke i ett lopp med 35.000 kronor i förstapris.<br class=""><strong>Tidigare vinnarna av utmaningen: </strong>Kajsa Frick (2015), Susanne H Osterling (2016), Jenni H Åsberg (2017), Emilia Leo (2018 och 2024), Kim Moberg (2019), Helena Ehn (2020), Linda Sedström (2021) samt Jennifer Persson (2022 och 2023).</p>



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



<p class="has-drop-cap">4 Axevalla (första start 18.30) delar kvällens expresstrav och V64-spel med Bollnäs och en delningsproposition upp till 1,5 miljoner kronor utgör huvuddelen av tävlingsdagen med sju av nio lopp.</p>



<p>Hästen som sticker ut är Robert Berghs nederländare <strong>Nickel Occagnes</strong> (e. Titan d’Occagnes), som vann sina fyra första starter hos Bergh och dessutom tog hem ett dubbelklasslopp inom rikstoton under Jägersros Derbyhelg. Nu har han två plumpar i rad i protokollet när han inleder från spår tolv i kvällens spårtrappa med tränare Bergh i vagnen.</p>



<p>Fredagens lunchbana är Kalmar (första start 12.20), där ett sexhästarsfält ser några intressanta namn över kort distans med voltstart. Som Veikko Haapakangas-tränade <strong>Emerald Island</strong> (e. Maharajah), som gör comeback efter över ett års uppehåll – och gör första starten sedan Margareta Wallenius-Klebergs Pokal 2024!</p>



<p>Emerald Island slutade oplacerad i det loppet som vanns av Bedazzled Sox och försvann från banan efter det. För tre veckor sedan kvalade hästen på 1.16,4. Totalt har han gjort 13 starter (6-3-1).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/10/251024.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap">5  Den svenska travkalendern presenterades på Svensk Travsports hemsida under gårdagen och där kunde läsas om vilka datum Breeders Crown-dagarna körs nästa år. De förändringar som Sulkysport skrev om tidigare i fallet Breeders Crown blev ett faktum och förslaget som Svensk Travsport lade fram klubbades igenom.</p>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="IzHOgLzbzW"><a href="https://sulkysport.se/xxxx-33/">Breeders Crown ändras</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Breeders Crown ändras” &ndash; Sulkysport" src="https://sulkysport.se/xxxx-33/embed/#?secret=ZzzBXcVmuB#?secret=IzHOgLzbzW" data-secret="IzHOgLzbzW" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>



<p>Som tidigare handlar det om nio Breeders&#8217; Crown-uttagningsdagar och 2026 kommer dessa att köras i <strong>Örebro</strong> (9/4), på <strong>Jägersro</strong> (14/5), i <strong>Rättvik</strong> (20/6), i <strong>Gävle</strong> (31/7), i <strong>Mantorp</strong> (5/8), i <strong>Boden</strong> (9/9), på <strong>Solvalla</strong> (11/9), på <strong>Bergsåker</strong> (14/10) och på <strong>Åby</strong> (14/10). Semifinaler körs på <strong>Solvalla</strong> (1/11) och finalerna kommer som vanligt att avverkas i <strong>Eskilstuna</strong> (14/11).</p>



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



<p class="has-drop-cap">6 Grupp II-loppen Prix Uranie (€120.000) och Prix Victor Regis (€120.000) avgörs ikväll på Vincennes och det handlar om de treåriga hästarna som gör upp över 2.175 meter. Stonas avdelning Prix Uranie innehåller två av kullens absolut bästa hästar i <strong>Magic Night</strong> (e. Helgafell) och <strong>Mille Etoiles</strong> (e. Prodigious). Den förstnämnda var först i mål i Criterium des 3 ans i september, men flyttades ned till andraplatsen efter en incident på upploppet. Philippe Allaires travare får gälla som favorit i kvällens löpning.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/crietriumdes3ans-617x332.jpeg" alt="" class="wp-image-767255" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Dramatik blev det på Vincennes när Magic Night var först i mål, men där segern gick till Mack de Blary. 
Foto: Gerard Forni</figcaption></figure>



<p>Hingstarnas uppgörelse har lockat endast åtta hästar till start och där blir högst sannolikt Thierry Duvaldestins <strong>Mack de Blary</strong> (e. Face Time Bourbon) hästen att slå. Mack de Blary var den som fick segern i Criterium des 3 ans och han går mot sin fjärde raka seger i Paris. </p>



<p><strong>Maitre Jacques</strong> (e. Rolling d&#8217;Heripre) och <strong>Mat Manathis</strong> (e. Booster Winner) står för det på papperet tuffaste motståndet till Mack de Blary.</p>



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



<p class="has-drop-cap">7 Samtidigt som det är fokus på norr, i Kanada, så körs flera lopp i Kindergarten Series ($25.000) för tvååringar på Meadowlands och det är faktiskt flertalet toppnamn som sluter upp i New Jersey. </p>



<p>I ena loppet för ston startar svenskfödda <strong>All Time Trot S</strong> (e. Googoo Gaagaa-Gorgeous Am), uppfödd av Robert Lindström och Ove Karlsson och den av Åke Svanstedt tränade tvååringen möter bland annat Nancy Takters <strong>Madam Cheval </strong>(e. Walner-Shake It Cerry), som får Jimmy Takter i vagnen. Svanstedt har även <strong>Kate</strong> (e. Gimpanzee-Earn Your Wings) i samma lopp.</p>



<p><strong>Busy Miss Lissy S</strong> (e. Calgary Games-Hill&#8217;s Angel) inledde karriären med fyra raka segrar och i kväll kan ny segerrad påbörjas då Jonathan Ahle sitter upp bakom Åke Svanstedts sto. Från samma stall kommer <strong>Flying Copper</strong> (e. Chapter Seven-Southwind Snow) ut. Jimmy Takter kör Nancys <strong>Pray For A Win</strong> (e. Father Patrick-Andover The Prize) medan Brett Beckwith kör stallkamraten <strong>Caviart Queen Emma</strong> (e. Bar Hopping-Caviart Quinn). </p>



<p>Hingstar och valacker har också chansen i två lopp i Kindergarten Series ($25.000). Mattias Melander stannar i USA och kör broder Marcus<strong> Neighver Punt</strong> (e. Bar Hopping-Twice Is Right) där man möter Svanstedts <strong>Mr Penner</strong> (e. Captain Corey-Wet My Whistle). </p>



<figure class="wp-block-image alignright size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2017/09/arianaghambooakslisa-617x374.jpg" alt="" class="wp-image-11572" style="width:584px;height:auto"/><figcaption class="wp-element-caption">Ariana G. vid segern i Hambletonian Oaks. Foto Lisa Photo</figcaption></figure>



<p>Melander-bröderna provar sedan lyckan med toppstammade <strong>American Power</strong> (e. Walner-Ariana G), som börjar från innerspår, men favorit i loppet lär Åke Svanstedts <strong>Magic Punk</strong> (e. Wishing Stone-I D Entity) bli. Magic Punk slutade tvåa bakom Apex i Peter Haughton Memorial i senaste starten. Per Engblom-tränade<strong> Trillion Times</strong> (e. Tactical Landing-Insurrection) finns också med bakom startbilens vingar i det andra loppet för hingstar och valacker.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Mot en miljon dollar
Jennifer bjuder in till kuskmatch och Kilström med förnamn Anders hedras traditionsenligt i Bollnäs.
Toppkallblod dyker upp på samma bana. Breeders Crown-finaler i natt och svenskarna sitter i framsätet.
Grupp-lopp på Vincennes och annat presenteras i Sju nyheter vid sju.
