
<p class="has-drop-cap">1 Solvalla, Åby och Bergsåker har alla tilldelats varsin Breeders Crown-dag under 2025. Jägersrohästar, vars närmaste grannbana i sammanhanget 2025 är Åby och Vaggeryd med avstånd på cirka 300 kilometer, har i år haft det klart kämpigast med att ta sig till semifinalerna, trots det stora upptagningsområdet av hästar i Skåne. Nu blir det troligtvis ändring på detta i och med det förslag Svensk Travsport lägger fram till landets banor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/rydensrandycl981031q-617x356.jpg" alt="" class="wp-image-746440"/><figcaption class="wp-element-caption">Rydens Randy och Catarina Lundström vid finalvinsten i Breeders Crown 1998. Foto: stalltz.se</figcaption></figure>



<p>Mellan åren 2023-2025 har uttagningarna till Breeders Crown fördelats mellan alla permanenta banor, men med facit i hand så har det inte varit något lyckat beslut att använda den strategin. Hästantalet på vissa av de arrangerande banorna har varit litet och det är bara att titta hur årets tävlingsdagar sett ut så förstår man att upplägget inte är hållbart. </p>



<p>Det har blivit dyrare för fler hästägare och tränare, utan att stora inkomster tillkommit de banor som arrangerat tävlingarna, detta i och med de, i flera fall, längre resorna som gjorts, samtidigt som publiksiffrorna inte ökat markant vid respektive tävlingstillfälle.</p>



<p>Som exempel kan Vaggeryds BC-dag i augusti nämnas, då 223 åskådare letade sig till arenan, så upplägget som valts under tre år var möjligen tänkt att bli festligt för arrangören, men där utfallet istället blev större kostnader för fler aktiva.</p>



<h2 class="wp-block-heading">Så här har det sett ut på Breeders Crown-dagarna så här långt i år.<br></h2>



<p><strong>Bana och datum</strong></p>



<ul class="wp-block-list">
<li>Anmälda hästar</li>



<li>Hemmahästar – Hästar från grannbana/grannbanor</li>
</ul>



<p><strong>Eskilstuna den 8 april</strong></p>



<ul class="wp-block-list">
<li>Antal anmälda hästar: 43</li>



<li>5 hemmahästar – 16 hästar från Solvalla</li>
</ul>



<p><strong>Årjäng den 22 maj</strong></p>



<ul class="wp-block-list">
<li>Antal anmälda hästar: 41</li>



<li>2 hemmahästar – 2 hästar från Färjestad</li>
</ul>



<p><strong>Dannero den 19 juni</strong></p>



<ul class="wp-block-list">
<li>Antal anmälda hästar: 39</li>



<li>0 hemmahästar – 19 hästar från Bergsåker</li>
</ul>



<p><strong>Visby den 30 juli*</strong></p>



<ul class="wp-block-list">
<li>Antal anmälda hästar: 48</li>



<li>4 hemmahästar</li>
</ul>



<p><strong>Vaggeryd den 10 augusti</strong></p>



<ul class="wp-block-list">
<li>Antal anmälda hästar: 48</li>



<li>0 hemmahästar – 21 hästar från Axevalla, Halmstad, Kalmar, Mantorp eller Åby, vilka samtliga har mindre än 200 km till värdbanan.</li>
</ul>



<p><strong>Umåker den 10 september</strong></p>



<ul class="wp-block-list">
<li>Antal anmälda hästar: 47</li>



<li>3 hemmahästar – 0 hästar från Skellefteå eller Solänget. 1 häst från Östersund.</li>
</ul>



<p><strong>Solvalla den 12 september</strong></p>



<ul class="wp-block-list">
<li>Antal anmälda hästar: 48</li>



<li>19 hemmahästar – 2 hästar från Eskilstuna</li>
</ul>



<p>*Vid Visbys Breeders Crown-dag räknades inga grannbanor.</p>



<p>Nu lägger Svensk Travsports sportavdelning fram ett förslag för Breeders Crown-uttagningar som mer riktar sig mot var hästarna finns i landet. </p>



<h2 class="wp-block-heading">Man föreslår bland annat:</h2>



<p>&#8230;<strong>att nio tävlingsdagar med fyra lopp ska köras, precis som idag.</strong></p>



<p>.<strong>..att uttagningarna med något undantag ska köras på mellan- och storbanor.</strong></p>



<p><strong>&#8230;att geografisk spridning som rimmar ungefär med olika landsdelars unghästunderlag. Två av nio dagar från Bergsåker och norrut, tre av nio tävlingsdagar från Axevalla och söderut och fyra av nio i området däremellan.</strong></p>



<p>.<strong>..att två av tävlingsdagarna med fördel kan vara permanenta och återkomma varje år; Rättvik i juni och Bergsåker i oktober.</strong></p>



<h2 class="wp-block-heading">Det konkreta förslaget från Svensk Travsport inför 2026:</h2>



<p><em>Bana – Datum och kommentar</em></p>



<ul class="wp-block-list">
<li><strong>Örebro</strong> – 9 april, 15 dagar före uttagningslopp till pokalloppen på Åby</li>



<li><strong>Jägersro</strong> – 14 maj, Gentlemannadagen</li>



<li><strong>Rättvik</strong> – 20 juni, Midsommartravet (krock med E3 och uttagning till Stosprinten)</li>



<li><strong>Gävle</strong> – 31 juli, 12 dagar efter Stochampionatet, 22 dagar före korta E3</li>



<li><strong>Mantorp</strong> – 5 augusti, 17 dagar efter Stochampionatet, 17 dagar före korta E3</li>



<li><strong>Boden</strong> – 9 september, två veckor efter Derbyuttagningar, två veckor före Kriterieuttagningar</li>



<li><strong>Solvalla</strong> – 11 september, två veckor efter Derbyuttagningar, två veckor före Kriterieuttagningar</li>



<li><strong>Bergsåker</strong> – 14 oktober, två veckor efter Kriterieuttagningar, två veckor före Breeders Crown-semifinal</li>



<li><strong>Åby</strong> – 14 oktober, två veckor efter Kriterieuttagningar, två veckor före Breeders Crown-semifinal</li>
</ul>



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



<p class="has-drop-cap">2 <strong>Gustaf Hallén</strong> är ett av Bodentravets största namn genom tiderna. Den mångfaldige championkusken – 17 titlar på hemmabanan och ytterligare fyra i Skellefteå under åren 1947-1984 – föddes i Selånger utanför Sundsvall 1920. Medelpadingen bytte Sundsvall mot Boden 1947 och blev en stor profil på landets nordligaste bana. Totalt vann Hallén 1.697 lopp som kusk och han började sin karriär som han slutade den – med seger på Bergsåker.</p>



<p>1939 vann han sitt första lopp med kallblodet Näcken och 48 år senare avslutade han kuskkarriären bakom <strong>Chacroll</strong>. 1969 blev han medlem i Tusenklubben efter vinst på hemmaplan med<strong> Babylon</strong>. Gustafs segerrikaste travare var varmbloden <strong>Jube</strong> (49 segrar) och <strong>Major Day</strong> (45), samt kallblodet <strong>Barry</strong> (41).</p>



<p>Sedan 1996 hyllar Bodentravet – vars infart pryds av en fyra meter hög staty föreställandes Gustaf Hallen körande häst – sin mångfaldige champion med Mäster Gustafs Pokal, som sedan 2013 avgörs med försök och final samma dag. Ikväll är det dags för årets upplaga, där finalvinnaren plockar hem 100.000 kronor. De sju bästa i varje försök möts i finalen över sprinterdistans med voltstart.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/petrisalmela-617x333.jpg" alt="" class="wp-image-352655"/><figcaption class="wp-element-caption">Petri Salmela. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>I den högre klassen har hemmatränaren Petri Salmela en nordamerikansk duo i <strong>Robinhood C.A</strong>. (e. Walner), som inledde med två raka segrar på svensk mark i våras/försomras, och segervane <strong>Speed Matters </strong>(e. Explosive Matter), som vunnit tio av 27 starter, men inte har startat sedan i augusti förra året.</p>



<p>Gustaf Hallén gick bort 2010.</p>



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



<p class="has-drop-cap">3 <strong>Boden</strong> (första start 18.20) är ena benet när expresstravet med saxad V64-omgång på fredagskvällarna är tillbaka efter ett längre sommaruppehåll.</p>



<p>Försöken i Mäster Gustafs Pokal ligger utanför V64-spelet. På kupongen finns bland annat ett stolopp, där ett segervant sto hittat vinnarformen igen. Jesper R Nilsson-tränade <strong>Fructose</strong> (e. Readly Express) inledde karriären med åtta segrar på de 13 första starterna. Sedan dröjde det 14 månader – och 21 starter – innan det var dags igen. Nu ståtar hon med två raka vinster på hemmaplan och jagar en tredje tillsammans med Jenny Engfors.</p>



<p><strong>Bergsåker</strong> (start 18.30) är den andra V64-banan och där gör en högkapabel sexåring comeback efter nästan 15 månaders tävlingsuppehåll. Daniel Redén-tränade <strong>Poleposition</strong> (e. Propulsion) har fyra rikstotosegrar bland karriärens tio vinster och har vunnit nästan hälften av livets starter totalt sett. I kvällens comeback har hästen dragit sjundespår bakom bilen tillsammans med Rikard N Skoglund.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/jonaseslykkaheataln-617x333.jpg" alt="" class="wp-image-749978"/><figcaption class="wp-element-caption">       Jonases Lykka och Jan-Olov Åberg i samband med kvalloppet förra hösten på 1.46,2. <br>       Foto Christer Norin/ALN</figcaption></figure>



<p>Fem finalister från Kallblodskriteriet och Kriteriestoet på <strong>Dannero</strong> tävlar ikväll. I Boden tar Jerker Bjurman ut <strong>Bjarte Kiro</strong> (e. Bäcklös Uriel), medan fyra treåringar möts på Bergsåker. Resultatmässigt lyckades Oskar Kylin Bloms <strong>Kallebo Elon </strong>(e. Tekno Odin) bäst på Dannero med femteplatsen i Kriteriet, där <strong>Oddfax</strong> (e. Odd Herakles) och <strong>Davidson R.F. </strong>(e. Tekno Jerven) slutade oplacerade. Den fjärde storloppsfinalisten är Jan-Olov Åbergs sto <strong>Jonases Lykka</strong> (e. Tekno Odin) som slogs om andrapriset i Kriteriestoet när hon galopperade kort före mål.</p>



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



<p class="has-drop-cap">4 Det är en smällfylld fredag på svensk travmark och hela fem banor är elden. Först ut är <strong>Årjäng</strong> (start 12.20) med lunchtävlingar.</p>



<p>Magnus Jakobssons kallblodssto<strong> Maj Mollyn</strong> (e. Dotterud Teddy) inledde säsongen på bästa ätt med tre raka segrar. Sedan blev det dock galopp två gånger i rad i större lopp – i dubbelcupfinalen för ston samt ST:s Guldtäcke – innan hon höll sig i rätt gångart senast med en tredjeplats i Åmål.</p>



<p>Nu ställs hon mot 14 motståndare på tre volter, där nio av dem tränas i Norge.</p>



<p><strong>Romme</strong> (start 17.25) och <strong>Kalmar</strong> (start 18.20) bjuder på breddlopp under fredagskvällen. På Romme dyker en minst sagt meriterad treåring upp. Katja Melkko-tränade <strong>Urano Unico</strong> (e. Orlando Vici) vann Vårfavoriten för hingstar och valacker på Solvalla i april och slog in 200.000 kronor på ett bräde. Sedan dess har det gått tyngre och i korta E3-finalen slutade hästen oplacerad. Nu kliver han ned i klass rejält när Melkkos partner Janne Soronen kliver upp i vagnen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/09/250919.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 Ytterligare två hingstar fyller på när <a href="https://sulkysport.se/varldsrekordhallare-avelsvarderas/" target="_blank" rel="noreferrer noopener">avelsvärderingen hålls på Sundbyholm i oktober</a>.<br>Det handlar om <strong>Lulius Boko</strong> (e. Muscle Hill-Julia Kemp) och <strong>Gareth Boko</strong> (e. Make It Happen-Vanilla Boko). Den sistnämnde är den klart mest meriterade av dem båda och hans tävlingskarriär innehåller bland annat: <br>Segrar i Breeders Crown (2 år) 2015, Svensk Uppfödningslöpning (2 år) 2015, Ibrahim Paschas lopp (3 år) 2016, Margaretas Tidiga Unghästserie (4 h/v, 2) 2017, Färjestads Jubileumslöpning (äldre) 2020, Prins Daniels lopp (äldre) 2021, Elitloppstrea 2021, seger i Gert Lindbergs lopp (guldfinal) 2021, Finlandia-Ajo-trea 2022, samt seger i Marschall Jozsef Emlekverseny (äldre, Budapest) 2022.</p>



<p>Lulius Bokos främsta merit är andraplatsen bakom Francesco Zet i Svenskt Travderby 2022, ett lopp till vilket han kom som obesegrad efter åtta starter. Senaste och sista (?) starten i karriären slutade med seger i gulddivisionen i Kalmar i januari 2024.</p>



<p><strong>Gareth Boko</strong> (12 år e. Make It Happen-Vanilla Boko e. Pine Chip)<br>1.09,1ak/7.443.842 kr. 93 st: 26-11-16</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/garethboko-617x333.jpg" alt="" class="wp-image-170227"/><figcaption class="wp-element-caption">Gareth Boko. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Lulius Boko</strong> (7 år e. Muscle Hill-Julia Kemp e. Chocolatier)<br>1.11,5ak*/2.610.000 kr. 11 st: 9-2-0</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/luliusbokobgm210922adamstromstalltz-617x406.jpg" alt="" class="wp-image-347773"/><figcaption class="wp-element-caption">Lulius Boko och Björn Goop. Foto Adam Ström/stalltz.se</figcaption></figure>



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



<p class="has-drop-cap">6 Ålborgs Stochampionat med 75.000 danska kronor till vinnaren avgörs idag och det är ett starkt startfält som sluter upp. Hälften av de tolv deltagarna kommer från finalen av Stoderbyt i Köpenhamn.</p>



<p>Michael Lönborgs <strong>Kaley D C</strong> (e. Wishing Stone) slutade tvåa bakom Kilimanjaro Face på Charlottenlund senast och visst ser det ut som att det här kan bli tionde segern i hennes 20:e start.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/skarmavbild20250628kl.16.01.16-617x339.jpg" alt="" class="wp-image-737046"/><figcaption class="wp-element-caption">Kaley D C vid seger under 2025.</figcaption></figure>



<p>P-O Pettersson-ägda <strong>Keep Cool Cash </strong>(e. Vivid Wise As), också tränad av Michael Lönborg, har haft dålig utdelning på sistone och från spår tolv bakom bilen lär hon få det tufft att segerstrida. </p>



<p>Steen Juuls välstammade <strong>Keen Lady Josselyn</strong> (e. Maharajah-Uza Josselyn) tillhör fältets bästa hästar.</p>



<p><strong>Startlista Ålborgs Stochampionat 2025<br></strong><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li><strong>Kleopatra S F</strong> (e. Readly Express) – Casper M Nielsen</li>



<li><strong>Songbird</strong> (e. Father Patrick) – Flemming Jensen</li>



<li><strong>Keen Lady Josselyn</strong> (e. Maharajah) – Jeppe Juel</li>



<li><strong>Karisma</strong> (e. Wishing Stone) – Mads Henriksen</li>



<li><strong>Komsålangborg</strong> (e. Hillustrious) – Knud Mönster</li>



<li><strong>Kaley D C</strong> (e. Wishing Stone) – Michael Lönborg</li>



<li><strong>Know Your Shadow</strong> (e. Cantab Hall) – Birger Jörgensen</li>



<li><strong>Kiwi Shadow</strong> (e. Broad Bahn) – Kasper Foget</li>



<li><strong>Kattejammer Cash </strong>(e. Cash And Go) – Rene Kjaer</li>



<li><strong>Kisser Vang</strong> (e. Googoo Gaagaa) – Jörgen Sjunnesson</li>



<li><strong>Karoline Gardenia</strong> (e. Great Challenger) – Steen Juul</li>



<li><strong>Keep Cool Cash</strong> (e. Vivid Wise As) – Jan Dahlgaard</li>
</ol>



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



<p class="has-drop-cap">7 Världsmästaren <strong>Lexus Kody</strong> (e. Archangel-Lexus Helios) och Yannick Gingras jagar ny triumf efter förra veckans vinst i Yonkers International Trot ($1.000.000). Ron Burkes sjuårige valack vann dessförinnan Maple Leaf Trot ($459.900) och har nog aldrig varit i bättre slag. </p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/skarmavbild20250913kl.21.04.18-e1757792796601-617x302.jpg" alt="" class="wp-image-767308" style="width:520px;height:auto"/><figcaption class="wp-element-caption">Lexus Kody höll undan på Yonkers.
Foto: Skärmbild ATG-live.</figcaption></figure>



<p>Men motstånd saknas definitivt inte. Marcus Melanders <strong>Periculum</strong> (e. Muscle Hill-Amour Heiress) blev fast med sparat efter invändig resa i samma lopp i lördags och från samma stall kommer även <strong>Oh Well</strong> (e. Muscle Hill-Fine Tuned Lady) ut. Dessutom startar Nancy Takter sina <strong>Highland Kismet</strong> (e. Father Patrick-Highland Top Hill) och <strong>French Wine</strong> (e. Bar Hopping-Creamy Mimi). Highland Kismet är yngst i fältet med sina fyra år.</p>



<p>Jim Doherty Memorial-vinnaren<strong> Atlantic Summer</strong> (e. Captain Corey) jagar ännu en titel i Indiana när Hoosier Park står som värd för The Kentuckiana Stallion Management ($259.000) för tvååriga ston i kväll.</p>



<figure class="wp-block-image size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/atlanticsummersep12-350x233.jpg" alt="" class="wp-image-767195"/><figcaption class="wp-element-caption">Atlantic Summer vinner före Lainey W. Foto: Dean Gillette</figcaption></figure>



<p>Ron Burkes sto sluggade sig förbi Marcus Melanders Lainey W kort före mål och vann på 1.12,0a/1.609 meter i Jim Doherty Memorial och precis som då sitter Ronnie Wrenn Jr i sulkyn i kväll.</p>



<p>Nancy Takters<strong> Madam Cheval</strong> (e. Walner-Shake It Cerry) får sällskap av Marcus Melanders trio <strong>Next Big Think</strong> (e. Greenshoe-Iteration), <strong>Creator</strong> (e. Walner-Hanna Bourbon) och svenskfödda <strong>Nezuko Kamado S</strong> (e. Chapter Seven-Zefira Kronos) I jakten på att försöka fälla Atlantic Summer.</p>



<p>I Phil Langley Memorial ($90.000) för treåriga hingstar och valacker jagar Ron Burkes <strong>On To Norway</strong> (e. Muscle Massive-One Class Act) årets 15:e seger i 16:e försöket, men valacken lär knappast bli favorit i loppet. Marcus Melanders <strong>Variegated</strong> (e. Chapter Seven-White Cheetah) slutade tvåa I New York Sire Stakes-finalen ($300.000) senast och han får, vid sidan om On To Norway, försöka besegra ($300.000) Pennsylvania Sire Stakes Final-vinnaren <strong>Fashion Green</strong> (e. Greenshoe-Fashion Athena), tränad av Jim Campbell.</p>
