
<p class="has-drop-cap">Det har körts 130 Breeders Crown-finaler sedan de första vinnarna <strong>Noble Tilly</strong> (e. Tibur) och <strong>Miss Hambleton</strong> (e. Super Mon) korades i treåringsklasserna på Axevalla 1991. När det på lördag är dags för årets finaler är det rykande jämnt i tränartoppen från loppets historia.</p>



<p>Daniel Redén leder på nio segrar och har sex chanser att kliva upp i tvåsiffrigt segerantal. Till finalen för de fyraåriga hingstarna/valackerna kvalade Redén in tre hästar, däribland årets vinnare av Europaderbyt <strong>Epic Kronos</strong>, som även slutade tvåa i Svenskt Travderby.</p>



<p>Robert Bergh och Timo Nurmos har åtta finalsegrar hittills, men duon har bara varsin finalist i Eskilstuna. Bergh hoppas på <strong>Googoo Casino</strong> (treåriga h/v), medan Nurmos finalist är <strong>Antognoni</strong> (fyraåriga h/v).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/01/danielreden1-617x333.jpg" alt="" class="wp-image-402846"/><figcaption class="wp-element-caption">Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Tränarligan i Breeders Crown:</strong></p>



<ul class="wp-block-list">
<li>Daniel Redén – 9</li>



<li>Robert Bergh – 8</li>



<li>Timo Nurmos – 8</li>



<li>Stig H Johansson – 7</li>



<li>Roger Walmann – 7</li>



<li>Stefan Hultman – 6</li>



<li>Stefan Melander – 6</li>



<li>Björn Goop – 5</li>



<li>Svante Båth – 4</li>



<li>Olle Goop – 4</li>



<li>Åke Svanstedt – 4</li>



<li>Johan Untersteiner – 4</li>



<li>Petri Puro – 3</li>
</ul>



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



<p class="has-drop-cap">Tjejerna har tjänat mer killarna på fingrarna även bland fyraåringarna. På treåringssidan var det 16,8 mot 14,5 miljoner kronor insprunget i stonas favör.<br>Bland fyraåringarna är motsvarande siffror 20.728.358 kronor för ston och 18.105.447 kronor för hingstar och valacker. Detta ger snittsiffrorna 1.727.363 respektive 1.508.787 kronor för årets BC-finalister.</p>



<p>Totalt har stona gjort 247 starter (82 segrar – snitt 33,2 procent) och hingstarna och valackerna har gjort 227 starter (75 segrar – snitt 33,0 procent).</p>



<h2 class="wp-block-heading">Startlista, fyraåriga hingstar/valacker</h2>



<p>2.140 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Eclipse As (e. Nuncio) – Ulf Ohlsson (Ville Karhulahti)</li>



<li>Bicc’s Tobee (e. Tobin Kronos) – Dwight Pieters (Maria Törnqvist)</li>



<li>Not For Sale (e. Readly Express) – Mats E Djuse (Daniel Wäjersten)</li>



<li>Kuiper (e. Face Time Bourbon) – Daniel Wäjersten STRUKEN</li>



<li>Epic Kronos (e. Muscle Hill) – Örjan Kihlström (Daniel Redén)</li>



<li>Holcombe Zet (e. Daley Lovin) – Per Lennartsson (Daniel Redén)</li>



<li>Cherokee Face (e. Bold Eagle) – Per Linderoth (Daniel Wäjersten)</li>



<li>Baron Tilly (e. Ready Cash) – Carl Johan Jepson (David Persson)</li>



<li>Gates Hanover (e. Walner) – Erik Adielsson (Daniel Redén)</li>



<li>Antognoni (e. Father Patrick) – Jorma Kontio (Timo Nurmos)</li>



<li>Flotilla (e. Readly Express) – Claes Sjöström (Roger Walmann)</li>



<li>Express Cash (e. Readly Express) – Andreas Lövdal</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/7dominotimetrot-617x333.jpg" alt="" class="wp-image-655203"/><figcaption class="wp-element-caption">Domino Time Trot vinner semifinalen för Claes Sjöström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Startlista, fyraåriga ston</h2>



<p>2.140 meter autostart.<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Graces Bird (e. Bird Parker) – Mats E Djuse (Jörgen Westholm)</li>



<li>Ester Degli Dei (e. Maharajah) – Robin Bakker (Paul Hagoort)</li>



<li>Domino Time Trot (e. International Moni) – Claes Sjöström</li>



<li>Daim Brodda (e. Readly Express) – Eirik Höitomt (Thor Borg)</li>



<li>Pure Diamond (e. Father Patrick) – Carl Johan Jepson (Fredrik Wallin)</li>



<li>Eteria (e. Tactical Landing) – Daniel Wäjersten</li>



<li>Kinglet Bird (e. Nuncio) – Örjan Kihlström (Daniel Redén)</li>



<li>Staro Raili (e. Maharajah) – André Eklundh (Sofia Aronson Hofstedt)</li>



<li>Käraste Sisu (e. Face Time Bourbon) – Mika Forss (Petri Salmela)</li>



<li>Maharasha (e. Maharajah) – Per Oleg Midtfjeld (Thor Borg)</li>



<li>Blast Pad (e. Uncle Lasse) – Jorma Kontio (Fredrik Wallin)</li>



<li>Elegance Kronos (e. Muscle Hill) – Björn Goop</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/skarmavbild20210903kl.22.33.36-617x451.jpg" alt="" class="wp-image-208525"/><figcaption class="wp-element-caption">Cherokee Face. Foto: Kolgjini Yearling Sale</figcaption></figure>



<p class="has-drop-cap">Bland fyraåringarna har 14 av 24 finalister har varit utbjudna på auktion, en av hästarna två gånger dessutom. <strong>Elegance Kronos</strong> ropades in av franske travförbundets ordförande Jean-Pierre Barjon på Solvalla Yearling Sale som ettåring för 1,4 miljoner kronor och är delat dyrast av hästarna som sålts på svenska auktioner.<br>Lika mycket betalades nämligen för <strong>Cherokee Face</strong> på Kolgjini Sales 2021 och köpare var Lennart Ågrens stall Srf Stable. Ågren handlade i samma prisklass även utomlands när han ropade in en då ettårig <strong>Gates Hanover</strong> i Lexington för 135.000 dollar för tre år sedan.</p>



<p>Ytterligare en miljonhäst finns i finalfälten och det handlar om en purfärsk sådan. Förra lördagen såldes nämligen <strong>Antognoni</strong> för 1.010.000 kronor på Travera. Köpare var kanadensiske toppkusken Yannick Gingras, som vann Hambletonian i år, och Mark Weavers.<br>Efter Breeders Crown-finalen reser valacken Antognoni över Atlanten och går i träning hos världens segerrikaste sulkytränare Ron Burke.</p>



<p>Och på avdelning dubbla försäljningar – Staro Raili kostade 160.000 kronor som ettåring på Kriterieauktionen och bjöds ut en andra gång som treåring på Travera, där hon bytte ägare för 625.000 kronor.</p>



<p><strong>Auktionspriser – hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li>Chrokee Face – Kolgjini Sales – 1.400.000 kr</li>



<li>Gates Hanover – Lexington – 135.000 dollar</li>



<li>Antognoni* – Travera – 1.010.000 kr</li>



<li>Flotilla – Menhammar Online Sales – 725.000 kr</li>



<li>Eclipse As – ITS-auktionen – 34.000 euro</li>



<li>Express Cash – Åby Yearling Sale – 110.000 kr</li>
</ul>



<p><em>* Antognoni såldes som fyraåring.</em></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/4elegancekronos-617x333.jpg" alt="" class="wp-image-503386"/><figcaption class="wp-element-caption">Elegance Kronos och Björn Goop håller undan för A Teaser i Oaksförsöket ifjol. Sedan följde hon upp med tredjeplatsen i finalen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Auktionspriser – ston:</strong></p>



<ul class="wp-block-list">
<li>Elegance Kronos – Solvalla Yearling Sale – 1.400.000 kr</li>



<li>Daim Brodda – Åby Yearling Sale – 900.000 kr</li>



<li>Staro Raili* – Travera – 625.000 kr</li>



<li>Eteria – ITS-auktionen – 40.000 euro</li>



<li>Ester Degli Dei – ITS-auktionen – 24.000 euro</li>



<li>Kinglet Bird** – Courant-auktionen – 160.000 kr</li>



<li>Staro Raili – Elitautionen – 160.000 kr</li>



<li>Domino Time Trot – Elitauktionen – 100.000 kr</li>



<li>Maharasha – Solvalla Yearling Sale – 100.000 kr</li>
</ul>



<p><em>* Staro Raili såldes andra gången som treåring.<br>** Kinglet Bird såldes som tvååring.</em></p>



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



<p class="has-drop-cap">I finalerna tävlar 20 svenskfödda fyraåringar om 1,6 miljoner i förstapris och dubbla prispengarna för övriga placeringar. Tre italienskfödda och en amerikansk travare får hälften så mycket. Alla svenska finalister är nämligen med i premiechansen.</p>



<p>De som inte är med i premiechansen är hingstarna <strong>Eclipse As</strong> och <strong>Gates Hanover</strong>, medan på stosidan handlar det om <strong>Ester Degli Dei</strong> och <strong>Eteria</strong>.</p>



<p>Prisskala premiechansade hästar (halva summorna för övriga hästar):<br>1.600.000-800.000-400.000-192.000-128.000-80.000 kronor</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/10/reden5-617x357.jpg" alt="" class="wp-image-645544"/><figcaption class="wp-element-caption">Epic Kronos vid segern i Europaderbyt på Vincennes. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap">Tvåa i svenska Derbyt och etta i Europaderbyt. Med de två stora prischeckarna är Daniel Redéns Epic Kronos vinstrikast av de svenskfödda fyraåringarna under 2024. Den summan kan han vässa som favirit i Breeders Crown-finalen. epic Kronos är ensam av hästarna på topp-fem som startar i finalen. Daniel Wäjerstens Kuiper hade kvalat in till finalen, men missar den på grund av skada.</p>



<p><strong>Vinstrikaste fyraåringar 2024 – hingstar/valacker:</strong><br><em>Häst (far) – Resultat – Prispengar</em></p>



<ol class="wp-block-list">
<li>Epic Kronos (e. Muscle Hill) – 9 st: 5-1-2 – 5.191.500 kr</li>



<li>Fame And Glory (e. Tactical Landing) – 5 st: 3-1-0 – 4.725.000 kr</li>



<li>Kuiper (e. Face Time Bourbon) – 12 st: 5-2-1 – 1.795.000 kr</li>



<li>Global Etalon (e. Brillantissime) – 10 st: 3-1-2 – 1.723.850 kr</li>



<li>Killiam Fromentro (e. Villiam) – 7 st: 4-0-0 – 1.341.019 kr</li>
</ol>



<p><em>Statistiken gäller svenskfödda och svensktränade fyraåringar.</em></p>



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



<p class="has-drop-cap">Stochampionatsvinnaren Kinglet Bird står i särklass bland de svensktränade, fyraåriga stona som tränas på svensk mark. 2,4 miljoner kronor drog hon in på ett bräde när hon vann Stochampionatet. Ytterligare 1,6 miljoner blir det om hon skulle lyckas vinna lördagens final i Eskilstuna.</p>



<p>Noterbart är att två av fem ston på fem-i-i-listan inte vunnit lopp i år, men sprungit in sjusiffrigt belopp.</p>



<p><strong>Vinstrikaste fyraåringar 2024 – ston:</strong><br><em>Häst (far) – Resultat – Prispengar</em></p>



<ol class="wp-block-list">
<li>Kinglet Bird (e. Nuncio) – 10 st: 2-2-2 – 2.753.000 kr</li>



<li>Farina (e. Readly Express) – 9 st: 0-3-0 – 1.297.500 kr</li>



<li>Kitty Hawk (e. Fourth Dimension) – 12 st: 2-2-1 – 1.213.000 kr</li>



<li>Dial Square (e. Ready Cash) – 7 st: 0-3-0 – 1.116.000 kr</li>



<li>Staro Raili (e. Maharajah) – 14 st: 5-3-0 – 1.079.000 kr</li>
</ol>



<p><em>Statistiken gäller svenskfödda och svensktränade fyraåringar.</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/05/barontillycjjm240504adamstromstalltz-617x393.jpg" alt="" class="wp-image-579937"/><figcaption class="wp-element-caption">Baron Tilly vinner Kungapokalen för Carl Johan Jepson. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">Kriterie- och Derbyvinnaren <strong>Fame And Glory</strong> (e. Tactical Landing) drabbades av halsinfektion inför finalen av Europaderbyt och tvingades strykas från finalen. Därmed blev det inte heller någon satsning mot Breeders Crown. Fjolårets Oaks-vinnare <strong>Adriatica</strong> (e. Bold Eagle) missar också finalen efter att inte ha tagit sig vidare från semifinalen.</p>



<p>Annars är många av 2020-kullens storloppsvinnare med när det drar ihop sig för kullens sista stora årgångsfinaler.</p>



<p><strong>Hingstar/valacker som vunnit lopp med 200.000 kronor eller mer i förstapris (inom parentes):</strong></p>



<ul class="wp-block-list">
<li><strong>Bicc’s Tobee</strong> – Klass II-final (220.000 kr), BC-semifinal 4 åt (200.000 kr)</li>



<li><strong>Kuiper</strong> – Svenskt Travderby, försök (200.000 kr), Europaderbyt, försök (200.000 kr), BC-semifinal 4 år (200.000 kr)</li>



<li><strong>Epic Kronos</strong> – Europaderbyt (2.242.500 kr), Margaretas Tidiga Unghästserie (300.000 kr), Svenskt Travderby, försök (200.000 kr), Europaderbyt, försök (200.000 kr), BC-semifinal 4 år (200.000 kr)</li>



<li><strong>Holcombe Zet</strong> – Svenskt Travderby försök (200.000 kr), BC-semifinal 3 år (200.000 kr)</li>



<li><strong>Baron Tilly</strong> – Kungapokalen (1.000.000 kr)</li>



<li><strong>Gates Hanover</strong> – Bluegrass Series ($54.500)</li>



<li><strong>Flotilla</strong> – E3 Chansen (225.000 kr)</li>
</ul>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/kingletbirdmaladam-617x333.jpg" alt="" class="wp-image-612089"/><figcaption class="wp-element-caption">Daniel Redén-tränade Kinglet Bird och Örjan Kihlström dansade undan till enkel seger i Stochampionatet i somras. Ikväll startar hon i ett försök i Breeders Crown. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p><strong>Ston som vunnit lopp med 200.000 kronor eller mer i förstapris (inom parentes):</strong></p>



<ul class="wp-block-list">
<li><strong>Ester Degli Dei</strong> – Breeders Crown, final 3 år (800.000 kr), Breeders Course, final 3 år (800.000 kr), Klaas J. Bootsman TCT Derby (€53.075), Fyraåringseliten för ston (500.000 kr), BC-semifinal 3 år (200.000 kr), BC-semifinal 4 år (200.000 kr)</li>



<li><strong>Domino Time Trot </strong>– BC-semifinal 4 år (200.000 kr)</li>



<li><strong>Daim Brodda</strong> – Derbystoet (2.000.000 kr), BC-semifinal 4 år (200.000 kr)</li>



<li><strong>Kinglet Bird</strong> – Stochampionatet (2.400.000 kr), Höstfavoriten (200.000 kr)</li>



<li><strong>Staro Raili</strong> – Margaretas Tidiga Unghästserie (300.000 kr)</li>



<li><strong>Käraste Sisu</strong> – E3 Chansen (225.000 kr)</li>



<li><strong>Maharasha</strong> – Margaretas Tidiga Unghästserie (300.000 kr)</li>
</ul>



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



<p class="has-drop-cap">Reijo Liljendahl lämnade Sverige för en fortsatt karriär mitt i sommaren och kvar blev hans unga starthästar som fördelades hos Daniel Wäjersten, Claes Sjöström och Ville Karhulahti. </p>



<p>I finalen för de fyraåriga stona möts två av dem: Sjöström-tränade <strong>Domino Time Trot</strong> och Wäjerstens <strong>Eteria</strong>. I hingstfinalen drog Karhulahti innerspår med en tredje, <strong>Eclipse As</strong>.</p>



<p>Ytterligare tre hästar från Liljendahls forna stall startar i treåringsfinalen för ston: <strong>Vivillion, Screen Time Limit</strong> och <strong>Beedrill</strong>. En åttondel av alla finalister har alltså inlett sina tävlingskarriärer i Reijo Liljendahls regi.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/esterdeglideirbm231118adamstromstalltz-617x397.jpg" alt="" class="wp-image-524399"/><figcaption class="wp-element-caption">Ester Degli Dei och Robin Bakker vid segern i Breeders Crown-finalen ifjol. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Paul Hagoort-tränade Maharajah-dottern <strong>Ester Degli Dei</strong> vann fjolårets Breeders Crown-final för treåriga ston och kan nu skriva in sig i ett exklusivt sällskap av dubbelvinnande Breeders Crown-hästar i Sverige.</p>



<p>Sju hästar har tagit dubbeln i BC och här finns 1990-talsdrottningarna <strong>Ina Scot</strong> och <strong>Lovely Godiva</strong> och 2020-talskungen <strong>Francesco Zet</strong> för att nämna några.</p>



<p><strong>Hästar som tagit dubbel i Breeders Crown:</strong></p>



<ul class="wp-block-list">
<li>1992-1993: Ina Scot (sto e. Allen Hanover)</li>



<li>1993-1994: Lovely Godiva (sto e. Ideal du Gazeau)</li>



<li>2007-2008: Sahara Dynamite (hingst e. Express Ride)</li>



<li>2008-2009: Yield Boko (hingst e. Viking Kronos)</li>



<li>2018-2019: Conrads Rödluva (sto e. S.J.’s Caviar)</li>



<li>2021-2022: Francesco Zet (hingst e. Father Patrick)</li>



<li>2022-2023: Queen Belina (sto e. Nuncio)</li>
</ul>



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



<p>På tal om utlandstränade finalister. Förutom <strong>Ester Degli Dei</strong> kommer två finalister från norrmannen Thor Borgs stall till finalen för de fyraåriga stona. <strong>Daim Brodda</strong> har tävlat flitigt i de svenskfödda storloppen i sommar och fick sin stora fullträff genom segern i Derbystoet. <strong>Maharasha</strong> har inte samma resultat, men kom till Solvalla i somras och vann en division i Margaretas Tidiga Unghästserie.</p>



<p>Som kusk tog Thor Borg 3.365 segrar och tillhör förstås en av de allra främsta travprofilerna i Norge. Han lade kuskkarriären – och hela travkarriären – på hyllan 2017.<br>– Det var inte roligt längre att kuska runt den mörka delen av året, har 72-åringen berättat för Sulkysport i en intervju inför Stochampionatet.</p>



<p>Han hade tänkt njuta av livet som pensionär, men det blev kortvarigt. Suget kom tillbaka och 2021 drog han igång som tränare igen. 23 hästar finns i stallet, där Borg driver verksamheten med Stian Hallenstvedt som sin högra hand i verksamheten.</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/11/daimbroddapris-617x333.jpg" alt="" class="wp-image-660008"/><figcaption class="wp-element-caption">Maria Widnes sköter både Daim Brodda (bilden) och Maharasha i fyraåringarnas stofinal. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Här är skötarna bakom finalisterna för fyraåriga hingstar/valacker:</strong></p>



<ol class="wp-block-list">
<li>Eclipse As – Jonna Roos</li>



<li>Bicc’s Tobee – Felicia Lindström</li>



<li>Not For Sale – Tilde Eliasson</li>



<li>Kuiper – Moa Bylund (struken)</li>



<li>Epic Kronos – Lina Pergenius</li>



<li>Holcombe Zet – Cecilia Lindén</li>



<li>Cherokee Face – Marja Ahonen</li>



<li>Baron Tilly – Lovisa Andersson</li>



<li>Gates Hanover – Elin Wickman</li>



<li>Antognoni – Linda Marttinen</li>



<li>Flotilla – Isabell Ahlin</li>



<li>Express Cash – Sara Andersson</li>
</ol>



<p><strong>Här är skötarna bakom finalisterna för fyraåriga ston:</strong></p>



<ol class="wp-block-list">
<li>Graces Bird – Jakob Asplund</li>



<li>Ester Degli Dei – Demi Veenstra</li>



<li>Domino Time Trot – Sara Norrström</li>



<li>Daim Brodda – Maria Widnes</li>



<li>Pure Diamond – Malin Mogset</li>



<li>Eteria – Ebba Karbelius</li>



<li>Kinglet Bird – Emelie Pettersson</li>



<li>Staro Raili – Nathalie Sandberg</li>



<li>Käraste Sisu – Rebecca Nisonen</li>



<li>Maharasha – Maria Widnes</li>



<li>Blast Pad – Malin Mogset</li>



<li>Elegance Kronos – Micka Johansson</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/gracesbirdmed-617x333.jpg" alt="" class="wp-image-660007"/><figcaption class="wp-element-caption">Jörgen Westholm-tränade Graces Bird och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Jörgen Westholm har som deluppfödare vunnit Breeders Crown-final två år i rad genom <strong>Queen Belina</strong> (e. Nuncio), som Solvallatränaren fött upp tillsammans med Håkan K Karlsson. I år finns Westholm med som deluppfödare igen. Tillsammans med Christer Nordin har han fött upp trekvartsmiljonärskan <strong>Graces Bird</strong>, som inleder från innerspår i finalen för de fyraåriga stona.</p>



<p>En ännu flitigare proffstränare som driver uppfödning är Stefan Melander och ”Tarzan” vet hur det känns att vinna BC som uppfödare, ägare och tränare, men inte som kusk. Det vet däremot sambon Catarina Lundström som styrde <strong>Rydens Randy</strong> till vinst 1998.<br>Daniel Redén (genom Brixton Medical AB) är den tredje, aktive proffstränaren som fött upp en av årets BC-finalister på fyraåringssidan med <strong>Holcombe Zet</strong>.</p>



<p><strong>Uppfödare med två eller fler vinnare:</strong></p>



<p><strong>Boko Stables (6)</strong></p>



<ul class="wp-block-list">
<li>2002 – Rae Boko</li>



<li>2006 – Vala Boko</li>



<li>2008 – Yield Boko</li>



<li>2009 – Yield Boko</li>



<li>2016 – Grant Boko</li>



<li>2022 – Lara Boko</li>
</ul>



<p><strong>Menhammar Stuteri (6)</strong></p>



<ul class="wp-block-list">
<li>2001 – Energetic</li>



<li>2002 – From Above</li>



<li>2010 – One Too Many</li>



<li>2011 – Perfectly Enough</li>



<li>2017 – Unrestricted </li>



<li>2019 – Brother Bill</li>
</ul>



<p><strong>Brixton Medical AB (3)</strong></p>



<ul class="wp-block-list">
<li>2015 – Trinity Zet</li>



<li>2021 – Francesco Zet</li>



<li>2022 – Francesco Zet</li>
</ul>



<p><strong>Broline International (3)</strong></p>



<ul class="wp-block-list">
<li>2009 – Ibiza Broline</li>



<li>2015 – Pacific Broline</li>



<li>2016 – Rhyme Broline</li>
</ul>



<p><strong>Erikssunds Trotting (3)</strong></p>



<ul class="wp-block-list">
<li>1995 – Imposant Sund</li>



<li>2005 – Triton Sund</li>



<li>2016 – In Toto Sund</li>
</ul>



<p><strong>Ulrik &#038; Ylva Lindh (3)</strong></p>



<ul class="wp-block-list">
<li>1997 – Simb Capi </li>



<li>1999 – Simb Zipper</li>



<li>2001 – Simb Moonrunner</li>
</ul>



<p><strong>Am Bloodstock AB (2)</strong></p>



<ul class="wp-block-list">
<li>2013 – Amazon Am</li>



<li>2019 – Forfantone Am</li>
</ul>



<p><strong>Carl Henrik Brandel (2)</strong></p>



<ul class="wp-block-list">
<li>1992 – Ina Scot</li>



<li>1993 – Ina Scot</li>
</ul>



<p><strong>Easy KB, Uppsala (2)</strong></p>



<ul class="wp-block-list">
<li>2004 – Camilla Highness</li>



<li>2005 – Fama Currit</li>
</ul>



<p><strong>Thomas Lind-Holm, Danmark (2)</strong></p>



<ul class="wp-block-list">
<li>2019 – Ganga Bae</li>



<li>2021 – Glamorous Rain</li>
</ul>



<p><strong>A &#038; H K Karlsson och Jörgen Westholm (2)</strong></p>



<ul class="wp-block-list">
<li>2022 – Queen Belina</li>



<li>2023 – Queen Belina</li>
</ul>



<p><strong>Ove Konradsson med flera (2)</strong></p>



<ul class="wp-block-list">
<li>2018 – Conrads Rödluva</li>



<li>2019 – Conrads Rödluva</li>
</ul>



<p><strong>Allevamento Kronos, Italien (2)</strong></p>



<ul class="wp-block-list">
<li>2015 – Treasure Kronos</li>



<li>2106 – Target Kronos</li>
</ul>



<p><strong>AB Lavec (2)</strong></p>



<ul class="wp-block-list">
<li>1994 – Tiba Lavec</li>



<li>2005 – Kung Lavec</li>
</ul>



<p><strong>A-L Lorentzon &#038; J-E Magnusson (2)</strong></p>



<ul class="wp-block-list">
<li>1995 – Sissela Ås </li>



<li>2005 – Joy Ås</li>
</ul>



<p><strong>Stefan Melander &#038; Ingemar Löfberg (2)</strong></p>



<ul class="wp-block-list">
<li>2010 – Aisle Stand</li>



<li>2013 – Digital Ink</li>
</ul>



<p><strong>Oskari Mäenpää, Finland (2)</strong></p>



<ul class="wp-block-list">
<li>2007 – Sahara Dynamite</li>



<li>2008 – Sahara Dynamite</li>
</ul>



<p><strong>Norra Näs Stuteri AB (2)</strong></p>



<ul class="wp-block-list">
<li>1993 – Lovely Godiva</li>



<li>1994 – Lovely Godiva</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/6biccstobee-617x333.jpg" alt="" class="wp-image-655198"/><figcaption class="wp-element-caption">Bicc&#8217;s Tobee vinner för Dwight Peters. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Här är ägarna och uppfödarna bakom finalisterna för fyraåriga hingstar/valacker:</strong><br><em>Finalist – Uppfödare – Hästägare</em></p>



<ol class="wp-block-list">
<li>Eclipse As – Allev. Della Serenissima Ss – Kent Gustavssons Schakt AB</li>



<li>Bicc’s Tobee – Carina Carlsson &#038; Conny Olofsson – Höökboet KB</li>



<li>Not For Sale – Prestera International AB – Bro Byggnads AB</li>



<li>Kuiper – Am Bloodstock AB – Stall Courant AB</li>



<li>Epic Kronos – Winged Lion Breeding AB – Stall Zet</li>



<li>Holcombe Zet – Brixton Medical AB – Stall Zet</li>



<li>Cherokee Face – Lutfi Kolgjini &#038; Anna Svensson – SRF Stable</li>



<li>Baron Tilly – Stall Tilly AB – Stall Tilly AB</li>



<li>Gates Hanover – Hanover Shoe Farms Inc – SRF Stable</li>



<li>Antognoni – Pellpac AB – Hs Trav AB &#038; Boko Stables Holland BV</li>



<li>Flotilla – Menhammar Stuteri AB – SRF Stable</li>



<li>Express Cash – Order by Stable AB – Stall Express Cash, Asap</li>
</ol>



<p><strong>Här är ägarna och uppfödarna bakom finalisterna för fyraåriga ston:</strong><br><em>Finalist – Uppfödare – Hästägare</em></p>



<ol class="wp-block-list">
<li>Graces Bird – Christer Nordin &#038; Jörgen Westholm – Norchri AB, m f</li>



<li>Ester Degli Dei – Az. Agr. Degli Dei SAS – L.C.J. Schalkoort</li>



<li>Domino Time Trot – Ove Karlsson &#038; Robert Lindström – Y&#038;B Trading AB, m f</li>



<li>Daim Brodda – Brodda Stuteri AB – Stall Tonga Racing AB</li>



<li>Pure Diamond – Marko Kreivi – Göteborg Smart Repair Center AB</li>



<li>Eteria – Scud. Sant’ Andrea S.R.L. – Bruni Racing Team AB, m f</li>



<li>Kinglet Bird – AM Bloodstock AB – JJK Sports Oy</li>



<li>Staro Raili – Staffan B Nilsson – Hjelte Restaurang AB</li>



<li>Käraste Sisu – Sisyfos Breeders AB – Sisu Racing Stable AB</li>



<li>Maharasha – Skeie Stable AS – Kjell Skatvedt</li>



<li>Blast Pad – Stefan T.Z. Melander HB – Martti Simonen</li>



<li>Elegance Kronos – Dvbk International AB – Ecurie Jean-Pierre Barjon</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/holcombezet-617x333.jpg" alt="" class="wp-image-604507"/><figcaption class="wp-element-caption">Daniel Redén-tränade Holcombe Zet och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Stall Zet dominerar bland hästägarna och har tagit åtta finalsegrar i Breeders Crown-historien. Stall T.Z. &#038; Lövis är tvåa på fem vinster.<br>Bland fyraåringarna kan Stall Zets segerantal utökas genom främst fyraåringsstjärnan <strong>Epic Kronos</strong>, men där stället stallet även hoppet till <strong>Holcombe Zet</strong>. </p>



<p><strong>Hästägare med två eller fler vinnare: </strong></p>



<p><strong>Stall Zet (8)</strong></p>



<ul class="wp-block-list">
<li>2015 – Trinity Zet</li>



<li>2016 – In Toto Sund</li>



<li>2018 – Conrads Rödluva</li>



<li>2019 – Conrads Rödluva</li>



<li>2020 – Mister Hercules</li>



<li>2021 – Francesco Zet</li>



<li>2021 – Glamorous Rain</li>



<li>2022 – Francesco Zet </li>
</ul>



<p><strong>Stall T.Z. &#038; Lövis (5)</strong></p>



<ul class="wp-block-list">
<li>1998 – Rydens Randy</li>



<li>2001 – Yatzy Brodda</li>



<li>2010 – Aisle Stand</li>



<li>2013 – Digital Ink</li>



<li>2015 – Nuncio</li>
</ul>



<p><strong>TNT Stable (3)</strong></p>



<ul class="wp-block-list">
<li>2007 – Sahara Dynamite</li>



<li>2008 – Sahara Dynamite</li>



<li>2009 – Red Hot Dynamite</li>
</ul>



<p><strong>Anders van Dapperen AB (2)</strong></p>



<ul class="wp-block-list">
<li>2022 – Queen Belina</li>



<li>2023 – Queen Belina</li>
</ul>



<p><strong>Ina-Q AB &#038; Kjell P Dahlström (2)</strong></p>



<ul class="wp-block-list">
<li>1992 – Ina Scot</li>



<li>1993 – Ina Scot</li>
</ul>



<p><strong>In the Zone AB, Bromma (2)</strong></p>



<ul class="wp-block-list">
<li>2011 – Kadett C.D. </li>



<li>2013 – Amazon Am</li>
</ul>



<p><strong>Srf Stable (2)</strong></p>



<ul class="wp-block-list">
<li>2019 – Forfantone Am</li>



<li>2021 – Fifty Cent Piece</li>
</ul>



<p><strong>Stall Tilly (2)</strong></p>



<ul class="wp-block-list">
<li>1991 – Noble Tilly</li>



<li>2014 – Infra Tilly</li>
</ul>



<p><strong>Stens Trot AB, Nacka Strand (2)</strong></p>



<ul class="wp-block-list">
<li>2022 – Dancer Brodde</li>



<li>2023 – Stens Rubin</li>
</ul>



<p><strong>Team Cololoco HB, Göteborg (2)</strong></p>



<ul class="wp-block-list">
<li>1993 – Lovely Godiva</li>



<li>1994 – Lovely Godiva</li>
</ul>



<p><strong>W. Horse AB, Enskede (2)</strong></p>



<ul class="wp-block-list">
<li>2009 – Yield Boko</li>



<li>2010 – Yield Boko</li>
</ul>



<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="mrlvMHKdlO"><a href="https://sulkysport.se/breeders-crown-klassiska-vinnare-i-fokus/">Breeders Crown: Klassiska vinnare i fokus</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Breeders Crown: Klassiska vinnare i fokus” &ndash; Sulkysport" src="https://sulkysport.se/breeders-crown-klassiska-vinnare-i-fokus/embed/#?secret=qjRVetr9He#?secret=mrlvMHKdlO" data-secret="mrlvMHKdlO" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>



<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="ZQIYUoCYho"><a href="https://sulkysport.se/bc-blir-lika-bra-som-vikingen/">BC: Blir lika bra som Vikingen?</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”BC: Blir lika bra som Vikingen?” &ndash; Sulkysport" src="https://sulkysport.se/bc-blir-lika-bra-som-vikingen/embed/#?secret=pcYuT4U5bJ#?secret=ZQIYUoCYho" data-secret="ZQIYUoCYho" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
