
<p class="has-drop-cap wp-block-paragraph">Fyraåringarnas Breeders Crown-finaler har samlat många av kullens främsta hästar och i snitt har de 24 finalisterna tjänat över två miljoner kronor!<br>Precis som bland treåringarna har stona i BC-finalerna tjänat mer än hingstarna och valackerna hittills i karriären.</p>



<p class="wp-block-paragraph">Den rikaste hästen finns på hingstsidan i form av <strong>Bedazzled Sox</strong> (e. Brillaintissime) som dragit in 6.092.000 kronor på sina 26 starter, eller fina 234.058 kronor per start. <strong>Bonneville W.I.</strong> (e. S.J.’s Caviar) är vassast bland stona med 214.937 kronor insprunget per start. Däremot är hon inte rikast i finalfältet. Den positionen innehar Stochampionsvinnaren <strong>Joy Sisu</strong> (e. Brillantissime) med 3.619.500 kronor på kontot.</p>



<p class="wp-block-paragraph">Totalt har hingstarna och valackerna sprungit in 25.036.452 kronor, vilket ger snittet 2.086.371 kronor.<br>De tolv fyraåriga stona i finalen har tillsammans travat ihop 26.986.135 kronor, eller i snitt 2.248.844 kronor i karriären.</p>



<p class="wp-block-paragraph">När det gäller antalet starter och segrar landar killarna på 252 starter och 86 segrar (21 starter/7,2 segrar i snitt), medan motsvarande siffror för stona är 244 starter och 72 segrar (20,3 starter/6 segrar i snitt).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/9barackface2-617x333.jpg" alt="" class="wp-image-509537"/><figcaption class="wp-element-caption">Barack Face höll emot Just A Gigolo i UET Grand Prix. Adrian Kolgjinis stjärna har gjort sin sista start för året. Foto Mathias Hedlund/Sulkysport.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Däremot saknas kullens två vinstrikaste svensktränade travarna i år. <strong>Barack Face</strong> (e. Ready Cash), som vann Europaderbyt och slutade tvåa i Derbyt, gjorde bokslut för säsongen efter triumfen på Solvalla i oktober, medan Derbyvinnaren <strong>Jovialitys</strong> pappa Chapter Sevens avkommor inte får vara med i Breeders Crown.</p>



<h2 class="wp-block-heading">Vinstrikaste fyraåringar 2023</h2>



<p class="wp-block-paragraph"><strong>Hingstar/valacker:</strong><br><em>Häst (far) – Resultat – Prispengar</em></p>



<ol class="wp-block-list">
<li><strong>Barack Face</strong> (e. Ready Cash) – 9 st: 4-1-1 – 5.195.500 kr</li>



<li><strong>Staro Mack Crowe</strong> (e. Bold Eagle) – 10 st: 3-4-1 – 2.349.000 kr</li>



<li><strong>Hustle Rain</strong> (e. Raja Mirchi) – 9 st: 4-0-1 – 1.790.000 kr</li>



<li><strong>Love Keeper</strong> (e. Propulsion) – 13 st: 2-4-2 – 1.634.250 kr</li>



<li><strong>Dancer Brodde</strong> (e. Bold Eagle) – 10 st: 4-1-0 – 1.610.500 kr</li>
</ol>



<p class="wp-block-paragraph"><strong>Ston:</strong><br><em>Häst (far) – Resultat – Prispengar</em></p>



<ol class="wp-block-list">
<li><strong>Joviality</strong> (e. Chapter Seven) – 10 st: 6-2-0 – 6.314.500 kr</li>



<li><strong>Jennifer Sisu</strong> (e. Propulsion) – 9 st: 4-4-1 – 3.002.500 kr</li>



<li><strong>Joy Sisu</strong> (e. Brillantissime) – 12 st: 2-1-2 – 2.689.000 kr</li>



<li><strong>Global Dancer</strong> (e. Carat Williams) – 10 st: 3-2-0 – 2.245.000 kr</li>



<li><strong>Decision Maker</strong> (e. Nuncio) – 14 st: 4-3-1 – 1.108.250 kr</li>
</ol>



<p class="wp-block-paragraph"><em>Statistiken gäller svenskfödda och svensktränade fyraåringar.</em></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/staromackcrowemal-617x333.jpg" alt="" class="wp-image-523521"/><figcaption class="wp-element-caption">Staro Mack Crowe plockade ned Miru Boko i Breeders Crown-semifinalen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Breeders Crown ingår i premiechansen och alla fyraåringar utom en tävlar om dubbla prispengar i finalerna. Det som inte får chansen till det är Daniel Redén-tränade <strong>Cabaret Artist</strong> (e. Propulsion), som är norskfödd.</p>



<p class="wp-block-paragraph"><strong>Prisskala premiechansade hästar (halva summorna för övriga hästar):</strong><br>1.600.000-800.000-400.000-192.000-128.000-80.000 kronor</p>



<h2 class="wp-block-heading">Startlista fyraåriga h/v</h2>



<p class="wp-block-paragraph"><strong>2.140 meter autostart</strong><br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Bedazzled Sox</strong> (e. Brillantissime) – Claes Sjöström (Roger Walmann)</li>



<li><strong>Staro Mack Crowe</strong> (e. Bold Eagle) – Rikard N Skoglund (Katja Melkko)</li>



<li><strong>A Fair Day</strong> (e. Maharajah) – Oscar Ginman (Elisabeth Almheden)</li>



<li><strong>Miru Boko</strong> (e. Royalty For Life) – Magnus A Djuse (Timo Nurmos)</li>



<li><strong>Game Brodde</strong> (e. S.J.’s Caviar) – Johan Untersteiner</li>



<li><strong>Michigan Bro</strong> (e. S.J.’s Caviar) – Markus B Svedberg</li>



<li><strong>Xanthis Harvey</strong> (e. Propulsion) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Winner Brodde</strong> (e. Raja Mirchi) – Peter Untersteiner (Johan Untersteiner)</li>



<li><strong>It’s Peppertime</strong> (e. Muscle Hill) – Jorma Kontio (Katja Melkko)</li>



<li><strong>Following</strong> (e. Nuncio) – Carl Johan Jepson (Stefan Melander)</li>



<li><strong>Joe Dalton</strong> (e. Father Patrick) – Mats E Djuse (Stefan P Pettersson)</li>



<li><strong>Bengan</strong> (e. Django Riff) – Björn Goop (Daniel Redén)</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/aureliaexpress-617x333.jpg" alt="" class="wp-image-519135"/><figcaption class="wp-element-caption">Aurelia Express och Mats E Djuse spårade varje meter av den andra BC-semfiinalen för fyraåriga ston. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="wp-block-paragraph"><strong>2.140 meter autostart</strong><br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Aurelia Express</strong> (e. Readly Express) – Mats E Djuse (Timo Nurmos)</li>



<li><strong>Decision Maker</strong> (e. Nuncio) – Björn Goop (Stefan Melander)</li>



<li><strong>O’Mara Zon</strong> (e. Maharajah) – Daniel Wäjersten</li>



<li><strong>Queen Belina</strong> (e. Nuncio) – Jörgen Westholm</li>



<li><strong>Cabaret Artist</strong> (e. Propulsion) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Jennifer Sisu</strong> (e. Propulsion) – Manus A Djuse (Timo Nurmos)</li>



<li><strong>Sommerbrise</strong> (e. Maharajah) – Carl Johan Jepson (Fredrik Wallin)</li>



<li><strong>Bonneville W.I. </strong>(e. S.J.’s Caviar) – Ulf Ohlsson (Timo Nurmos)</li>



<li><strong>Mahala</strong> (e. Propulsion) – Martin P Djuse (Daniel Redén)</li>



<li><strong>Joy Sisu</strong> (e. Brillantissime) – Mika Forss (Petri Salmela)</li>



<li><strong>Bikana Wine</strong> (e. Propulsion) – Johan Untersteiner</li>



<li><strong>Kayla Westwood</strong> (e. Maharajah) – Erik Adielsson (Mattias Djuse)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/decisionmaker-617x333.jpg" alt="" class="wp-image-519132"/><figcaption class="wp-element-caption">Decision Maker och Björn Goop ledde hela vägen i den första BC-semfinalen för fyraåriga ston. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Stefan Melander har vunnit svenska Breeders Crown-finaler som uppfödare, ägare, tränare och körsven. Av hans sex finalvinnare i historien har han fött upp <strong>Aisle Stand</strong> (e. Scarlet Knight) och <strong>Digital Ink</strong> (e. Super Photo Kosmos), köpt <strong>Nuncio</strong> (e,. Andover Hall) på auktion i USA och inhandlat <strong>Yatzy Brodda</strong> (e. Alf Palema) och <strong>Rydens Randy</strong> (e. Alf Palema) i Sverige, samt tränat <strong>Ganga Bae</strong> (e. Muscle Hill) åt Stall Courant.</p>



<p class="wp-block-paragraph">En vinnare har han kört själv, Nuncio, medan Rydens Randy lotsades till vinst av sambon Catarina Lundström.</p>



<p class="wp-block-paragraph">Nu har ”Tarzan” en fyraåring i vardera final och båda hästarna är både uppfödda och ägda av Melander – och båda har hans senaste superstjärna Nuncio som pappa. Stoet <strong>Decision Maker</strong> har klivit in i kulltoppen i år, medan hingsten <strong>Following</strong> inledde tävlkingskarriären redan som tvååring på andra sidan Atlanten hos brorsonen Marcus Melander.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/kaylawestwoodpris-617x333.jpg" alt="" class="wp-image-358331"/><figcaption class="wp-element-caption">Mattias Djuse-tränade Kayla Westwood med sin ägare Nymanwänseth Byggmästare AB, Nils Nyman. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Från 130.000 kronor till 1.050.000 kronor. Åtta av de 24 fyraåriga BC-finalisterna har bytt ägare på auktion och ytterligare fem av dem har funnits med i auktionskataloger.</p>



<p class="wp-block-paragraph">Mattias Djuse-tränade <strong>Kayla Westwood</strong> (e. Maharajah) såldes under Derbyhelgen som treåring på Traveras lördagsauktion när Nymanwänseth Byggmästare AB, Östersund, ropade hem henne för 1.050.000 kronor. Det tangerade nästan summan Kayla hunnit springa in hittills, 1.060.000 kronor.<br>Efter ägarbytet har Kayla Westwood fortsatt tillhöra kulltoppen. Hon slutade delad trea i Oaks ifjol och har i år tagit andraplatsen i Drottning Silvias Pokal bakom Joviality och slutat fyra i Stosprintern.</p>



<p class="wp-block-paragraph">På ettåringsauktionerna kostade norskfödda <strong>Cabaret Artist</strong> (e. Propulsion) mest. 480.000 kronor slogs klubban på när Daniel Redén ropade in stoet.</p>



<p class="wp-block-paragraph"><strong>Så mycket kostade BC-hästarna på auktion:</strong><br><em>Häst – Auktion – År – Pris</em></p>



<ul class="wp-block-list">
<li><strong>Kayla Westwood</strong> – Travera nätauktion – 2022 – 1.050.000 kr</li>



<li><strong>Cabaret Artist</strong> – Solvalla Yearling Sale – 2020 – 480.000 kr</li>



<li><strong>Bedazzled Sox</strong> – Åby Yearling Sale – 2020 – 400.000 kr</li>



<li><strong>Bengan</strong> – Kriterieauktionen – 2020 – 400.000 kr</li>



<li><strong>It’s Peppertime</strong> – Åby Yearling Sale – 2020 – 340.000 kr</li>



<li><strong>Game Brodde</strong> – Kriterieauktionen – 2020 – 230.000 kr</li>



<li><strong>Joe Dalton</strong> – Solvalla Yearling Sale – 2020 – 220.000 kr</li>



<li><strong>Sommerbrise</strong> – Solvalla Yearling Sale – 2020 – 130.000 kr</li>
</ul>



<p class="wp-block-paragraph"><strong>Fotnot: </strong>Queen Belina ropades åter för 250.000 kronor på Kriterieauktionen 2020, medan Bedazzled Sox, It’s Peppertime, Joy Sisu och Xanthis Harvey var strukna från Elitauktionen 2020.</p>



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



<p class="has-drop-cap wp-block-paragraph">De fyraåriga stona har tjänat mer än hingstarna och valackerna hittills i karriären och faktum är att samtliga tolv ston har tagit en förstaprischeck på 200.000 kronor eller mer!</p>



<p class="wp-block-paragraph">De tyngsta titlarna har fjolårets Oaks-vinnare <strong>Bonneville W.I.</strong> (e. S.J.’s Caviar) och årets Stochampionatsetta <strong>Joy Sisu</strong> (e. Brillantissime) lagt beslag på, men här finns också fjolårets Breeders Crown-vinnare <strong>Queen Belina</strong> (e. Nuncio) och Stoderbyvinnaren i Norge, <strong>Cabaret Artist</strong> (e. Propulsion).</p>



<p class="wp-block-paragraph"><strong>Ston som vunnit lopp med 200.000 kronor eller mer i förstapris:</strong></p>



<ul class="wp-block-list">
<li><strong>Aurelia Express</strong> – Breeders Crown-semifinal 2023 (200.000 kr)</li>



<li><strong>Bikana Wine</strong> – Margaretas Tidiga Unghästserie 2023 (300.000 kr)</li>



<li><strong>Bonneville W.I. </strong>– Svenskt Trav-Oaks 2022 (2.800.000 kr)</li>



<li><strong>Cabaret Artist</strong> – Stoderbyt, Norge 2023 (890.545 kr), Sweden International Yearling Sales Auktionslopp 2022 (250.000 kr)</li>



<li><strong>Decision Maker</strong> – Margaretas Tidiga Unghästserie 2023 (300.000 kr), Breeders Crown-semifinal 2023 (200.000 kr)</li>



<li><strong>Jennifer Sisu</strong> – Breeders Crown-semifinal 2022 (200.000 kr)</li>



<li><strong>Joy Sisu</strong> – Stochampionatet 2023 (2.400.000 kr), ASVT Trottex Auktionslopp 2021 och 2022 (200.000 kr), </li>



<li><strong>Kayla Westwood</strong> – Margaretas Tidiga Unghästserie 2022 (300.000 kr)</li>



<li><strong>Mahala</strong> – Diamantstoet final 2023 (220.000 kr)</li>



<li><strong>O’Mara Zon</strong> – Breeders Crown-semifinal 2022 och 2023 (200.000 kr)</li>



<li><strong>Queen Belina</strong> – Breeders Crown-final 2022 (1.600.000 kr)</li>



<li><strong>Sommerbrise</strong> – Sweden International Yearling Sales Auktionslopp 2021 (250.000 kr)</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/jennifersisustart-617x333.jpg" alt="" class="wp-image-523538"/><figcaption class="wp-element-caption">Jennifer Sisu och Magnus A Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Att stå på tur för en klassisk seger måste man verkligen säga att Timo Nurmos-tränade <strong>Jennifer Sisu</strong> (e. Propulsion) gör. Hon kvalade via seger i semifinalen in till BC-finalen förra året, men gick lottlös denna.<br>I år har Jennifer Sisu varit med i Stosprintern, Stochampionatet och Derbystoet – och slutat tvåa i samtliga finaler! Nu är hon framme i kullens sista stora slag och frågan är om ”2-orna” ska rätas ut till en etta den här gången?</p>



<p class="wp-block-paragraph">Stallkamraten <strong>Aurelia Express</strong> (e. Readly Express) har också varit slitig i storloppen, där hon ifjol ledde till kort före mål i Oaks då Bonnevillwe W.I. klev förbi. Finalplats i Breeders Crown ifjol (femma) och både Stochampionatet (femma) och Derbystoet i år finns på meritlistan.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/omarazonqueenbelina-617x333.jpg" alt="" class="wp-image-519177"/><figcaption class="wp-element-caption">O&#8217;Mara Zon plockade ned Queen Belina i Breeders Crown-semifinalen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Ett brett storloppsregister har också Daniel Wäjerstens <strong>O’Mara Zon</strong> (e. Maharajah). Andraplatsen i korta E3 är tyngsta meriten så här långt, men O’Mara Zon var även fyra i Breeders Crown och finalist i Oaks förra året.<br>I år inledde hon storloppssäsongen med tredjeplatsen i Drottning Silvias Pokal och slutade sexa i Stochampionatet. I Breeders Crown väntar hennes sjätte stora final.</p>



<p class="wp-block-paragraph">För Mattias Djuses <strong>Kayla Westwood</strong> (e. Maharajah) blir det också sjätte årgångsfinalen. Ifjol slutade hon trea i Oaks, fyra i långa E3 och sexa i Breeders Crown, och i år inledde hon med att vara placeringen före O’Mara Zon i Drottningspokalen som tvåa bakom Joviality och fyra i Stosprintern.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/bedazzledsox-617x333.jpg" alt="" class="wp-image-519201"/><figcaption class="wp-element-caption">Bedazzled Sox vinner BC-semi för Claes Sjöström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">När det gäller de fyraåriga hingstarna och valackerna har faktiskt hälften av finalisterna inte tagit någon förstaprischeck på 200.000 kronor eller mer. Der handlar om <strong>Bengan, Game Brodde, It’s Peppertime, Michigan Bro, Miru Boko</strong> och <strong>Winner Brodde</strong>.</p>



<p class="wp-block-paragraph">Men detta finns det andra som gjort – som Roger Walmann-tränade <strong>Bedazzled Sox</strong> (e. Brillantissime). Hela sex gånger har han plockat en segercheck värd 200.000 kronor eller mer med toppsiffran i Långa E3-finalen ifjol där han som premiechansad plockade hem två miljoner kronor.<br>Dubbelt så mycket tog Daniel Redén-tränade <strong>Xanthis Harvey</strong> (e. Propulsion), som verkligen valde rätt tillfälle att ta sin enda seger hittills värd 00.000 eller mer. Fjolårets vinnare av Svenskt Travkriterium kunde kvittera ut fyra miljoner kronor för den triumfen.<br>Sjusiffrigt plockade även Stefan Melander-tränade <strong>Following</strong> (e. Nuncio), som vann korta E3-finalen.</p>



<p class="wp-block-paragraph">Däremot saknas både vinnaren av Kungapokalen – <strong>Dancer Brodde</strong> (e. Dancer Brodde) – och Sprintermästaren <strong>Hustle Rain</strong> (e. Raja Mirchi) i lördagens final.</p>



<p class="wp-block-paragraph"><strong>Hingstar/valacker som vunnit lopp med 200.000 kronor eller mer i förstapris:</strong></p>



<ul class="wp-block-list">
<li><strong>A Fair Day</strong> – Breeders Crown-semifinal 2023 (200.000 kr)</li>



<li><strong>Bedazzled Sox</strong> – Långa E3 final 2022 (2.000.000 kr), Margaretas Tidiga Unghästserie 2022 och 2023 (300.000 kr), Breeders Crown-semifinal 2022 och 2023 (200.000 kr), Grand Prix de l’U.E.T.-försök 2023 (200.000 kr)</li>



<li><strong>Following</strong> – Korta E3 final 2022 (1.000.000 kr)</li>



<li><strong>Joe Dalton</strong> – Margaretas Tidiga Unghästserie 2022 (300.000 kr)</li>



<li><strong>Staro Mack Crowe</strong> – Prix Readly Express 2023 (600.000 kr), Breeders Crown-semifinal 2023 (200.000 kr)</li>



<li><strong>Xanthis Harvey</strong> – Svenskt Travkriterium 2022 (4.000.000 kr)</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/11/afairdaypris-1-617x333.jpg" alt="" class="wp-image-523527"/><figcaption class="wp-element-caption">Elisabeth Almheden tränar A Fair Day. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">En katt bland hermelinerna – enda amatörtränade hästen av 48 i Breeders Crown-finalerna är <strong>A Fair Day</strong> (e. Maharajah), som tränas av Kalmars Elisabeth Almheden.<br>A Fair Day testade i både Kriteriekval och Breeders Crown-semifinal förra året, men utan framgång. I år har hästen lyft sig ytterligare ett par snäpp och travade 1.11,1ak vid STL-seger i Tingstyd i början av sommaren.</p>



<p class="wp-block-paragraph">Veckan före BC-semifinalen genrepade han på bästa sätt med att vinna finalen i hemmabanans fyraåringsserie i imponerande stil och semifinalen togs hem på enklaste vis efter tidig ledning.</p>



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



<p class="has-drop-cap wp-block-paragraph">Det har körts 126 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 class="wp-block-paragraph">Daniel Redén klev upp i ensam ledning förra året sedan <strong>Francesco Zet </strong>(e. Father Patrick) vunnit finalen för de fyraåriga hingstarna och valackerna. Det var Redéns nionde triumf som tränare, en mer än Robert Bergh (segerlös ifjol) och Timo Nurmos, som plockade en finalseger genom <strong>Lara Boko</strong> (e. Djali Boko).</p>



<p class="wp-block-paragraph">Redén lutar sig mot <strong>Holcombe Zet</strong> (e. Daley Lovin), <strong>Cabaret Artist</strong> (e. Propulsion), <strong>Mahala</strong> (e. Propulsion), <strong>Xanthis Harvey</strong> (e. Propulsion) och <strong>Bengan</strong> (e. Django Riff). Nurmos kontrar å sin sida med en stark uppställning i form av Kriterievinnaren <strong>Fame And Glory</strong> (e. Tactical Landing), <strong>Nouri di Quattro</strong> (e. Southwind Frank), Oaksvinnaren <strong>Adriatica</strong> (e. Bold Eagle), <strong>Aurelia Express</strong> (e. Readly Express), <strong>Jennifer Sisu</strong> (e. Propulsion), <strong>Bonneville W.I. </strong>(e. S.J.’s Caviar) och <strong>Miru Boko</strong> (e. Royalty For Life). </p>



<p class="wp-block-paragraph">Robert Bergh gick däremot lottlös från semifinalerna och saknar finalist i år.</p>



<h2 class="wp-block-heading">Tränarligan i Breeders Crown</h2>



<p class="wp-block-paragraph"><em>Tränare – Segrar</em></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>Petri Puro – 3</li>



<li>Johan Untersteiner – 3</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/bonnevillew.i.rebeccasjoberg-617x333.jpg" alt="" class="wp-image-490980"/><figcaption class="wp-element-caption">Fjolårets Oaksvinnare Bonneville W.I. är en av Rebecca Sjöbergs två starthästar i Breeders Crowe. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Bakom varje framgångsrik häst står en skötare och tre av tjejerna bakom de fyraåriga finalisterna har haft extra stora framgångar.</p>



<p class="wp-block-paragraph">Stefan Melander har en finalist i vardera klass genom <strong>Following</strong> (e. Nuncio) och <strong>Decision Maker</strong> (e. Nuncio) och Sanna Ljungberg är skötare till båda.<br>Daniel Redén-anställda Jenny Sundin sköter <strong>Cabaret Artist</strong> (e. Propulsion) och <strong>Mahala</strong> (e. Propulsion), medan Rebecca Sjöberg hos Timo Nurmos mönstrar <strong>Jennifer Sisu</strong> (e. Propulsion) och <strong>Bonneville W.I. </strong>(e. S.J.’s Caviar). Rebecca får en fullspäckad lördag, då hon dessutom passar <strong>Nouri di Quattro</strong> (e. Southwind Frank), som startar i finalen för treåriga hingstar och valacker.</p>



<p class="wp-block-paragraph">Här är tjejerna och killarna som tar hand om finalisterna.</p>



<p class="wp-block-paragraph"><strong>Fyraåriga h/v:</strong></p>



<ol class="wp-block-list">
<li>Bedazzled Sox –  Isabell Ahlin</li>



<li>Staro Mack Crowe – Melissa Melkko</li>



<li>A Fair Day –  Malin Almheden</li>



<li>Miru Boko – Saara Jaakonsaari</li>



<li>Game Brodde – Axel Ritzman</li>



<li>Michigan Bro – Emilia Rooth</li>



<li>Xanthis Harvey – Ellinor Wennebring</li>



<li>Winner Brodde – Julia Andersson</li>



<li>It’s Peppertime – Melissa Melkko</li>



<li>Following – Sanna Ljungberg</li>



<li>Joe Dalton – Cecilia Sognemyr</li>



<li>Bengan – Carolina Persson</li>
</ol>



<p class="wp-block-paragraph"><strong>Fyraåriga ston:</strong></p>



<ol class="wp-block-list">
<li>Aurelia Express – Katariina Nurmonen</li>



<li>Decision Maker – Sanna Ljungberg</li>



<li>O’Mara Zon – Camilla Björk</li>



<li>Queen Belina – Jenny Martinsson</li>



<li>Cabaret Artist – Jenny Sundin</li>



<li>Jennifer Sisu – Rebecca Sjöberg</li>



<li>Sommerbrise – Nathalie Pettersson</li>



<li>Bonneville W.I. – Rebecca Sjöberg</li>



<li>Mahala – Jenny Sundin</li>



<li>Joy Sisu – Ira-Maria Lahti</li>



<li>Bikana Wine – Peter Martinsson</li>



<li>Kayla Westwood – Nathalie Vingmyr</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/03/puropetriglad-617x333.jpg" alt="" class="wp-image-142978"/><figcaption class="wp-element-caption">Petri Puro. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Halmstadtränaren Petri Puro har plockat tre Breeders Crown-segrar – <strong>Camilla Highness</strong> (e. Super Arnie), <strong>Fama Currit</strong> (e. Viking Kronos) och <strong>Commander Crowe</strong> (e. Juliano Star). Den sistnämnde är även Puro uppfödare till. 2007 slog Commander Crowe till i finalen som avgjordes på Mantorptravet och Johnny Takter satt i sulkyn.<br>Nu kan Puro lägga en ny uppfödarseger till meritlistan, då han är uppfödare till en av årets kometer i kullen <strong>Staro Mack Crowe</strong> (e. Bold Eagle), som varit tvåa i Sprintermästaren och trea i Europaderbyt i år.</p>



<p class="wp-block-paragraph">Förutom Petri Puro och Stefan Melander har även Jörgen Westholm (<strong>Queen Belina</strong> e. Nuncio) och Daniel Redén (<strong>Mahala</strong> e. Propulsion) egna uppfödningar till start i fyraåringarnas BC-finaler.</p>


<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Uppfödare med två eller fler vinnare								</h3>
<div class="content">
<p class="wp-block-paragraph"><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 class="wp-block-paragraph"><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&nbsp;</li>
<li>2019 – Brother Bill</li>
</ul>
<p class="wp-block-paragraph"><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 class="wp-block-paragraph"><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 class="wp-block-paragraph"><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 class="wp-block-paragraph"><strong>Ulrik &amp; Ylva Lindh (3)</strong></p>
<ul class="wp-block-list">
<li>1997 – Simb Capi&nbsp;</li>
<li>1999 – Simb Zipper</li>
<li>2001 – Simb Moonrunner</li>
</ul>
<p class="wp-block-paragraph"><strong>Am Bloodstock AB (2)</strong></p>
<ul class="wp-block-list">
<li>2013 – Amazon Am</li>
<li>2019 – Forfantone Am</li>
</ul>
<p class="wp-block-paragraph"><strong>Carl Henrik Brandel (2)</strong></p>
<ul class="wp-block-list">
<li>1992 – Ina Scot</li>
<li>1993 – Ina Scot</li>
</ul>
<p class="wp-block-paragraph"><strong>Easy KB, Uppsala (2)</strong></p>
<ul class="wp-block-list">
<li>2004 – Camilla Highness</li>
<li>2005 – Fama Currit</li>
</ul>
<p class="wp-block-paragraph"><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 class="wp-block-paragraph"><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 class="wp-block-paragraph"><strong>Allevamento Kronos, Italien (2)</strong></p>
<ul class="wp-block-list">
<li>2015 – Treasure Kronos</li>
<li>2106 – Target Kronos</li>
</ul>
<p class="wp-block-paragraph"><strong>AB Lavec (2)</strong></p>
<ul class="wp-block-list">
<li>1994 – Tiba Lavec</li>
<li>2005 – Kung Lavec</li>
</ul>
<p class="wp-block-paragraph"><strong>A-L Lorentzon &amp; J-E Magnusson (2)</strong></p>
<ul class="wp-block-list">
<li>1995 – Sissela Ås&nbsp;</li>
<li>2005 – Joy Ås</li>
</ul>
<p class="wp-block-paragraph"><strong>Stefan Melander &amp; Ingemar Löfberg (2)</strong></p>
<ul class="wp-block-list">
<li>2010 – Aisle Stand</li>
<li>2013 – Digital Ink</li>
</ul>
<p class="wp-block-paragraph"><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 class="wp-block-paragraph"><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></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 class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/walmannrogeragrenlennart220702adamstromstalltz-617x459.jpg" alt="" class="wp-image-342282"/><figcaption class="wp-element-caption">Roger Walmann och Lennart Ågren har firat stora framgångar ihop under årens lopp. Foto Adam Ström/StallTZ.se.</figcaption></figure>



<p class="wp-block-paragraph">Storhästägaren Lennart Ågren – Srf Stable – kan se tillbaka på två finalsegrar i svenska Breeders Crown. Detta genom <strong>Fortantone Am</strong> (e. Muscle Hill) och USA-födda <strong>Fifty Cent Piece</strong> (e. Muscle Hill).</p>



<p class="wp-block-paragraph">Hoppet i lördagens finaler heter <strong>Bedazzled Sox</strong> (e. Brillantissime), som vann sin semifinal och inleder från innerspår bakom bilen i finalen för de fyraåriga hingstarna och valackerna.</p>


<div class="factbox full minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Hästägare med två eller fler vinnare								</h3>
<div class="content">
<p class="wp-block-paragraph"><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&nbsp;</li>
</ul>
<p class="wp-block-paragraph"><strong>Stall T.Z. &amp; 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 class="wp-block-paragraph"><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 class="wp-block-paragraph"><strong>Ina-Q AB &amp; Kjell P Dahlström (2)</strong></p>
<ul class="wp-block-list">
<li>1992 – Ina Scot</li>
<li>1993 – Ina Scot</li>
</ul>
<p class="wp-block-paragraph"><strong>In the Zone AB, Bromma (2)</strong></p>
<ul class="wp-block-list">
<li>2011 – Kadett C.D.&nbsp;</li>
<li>2013 – Amazon Am</li>
</ul>
<p class="wp-block-paragraph"><strong>Srf Stable (2)</strong></p>
<ul class="wp-block-list">
<li>2019 – Forfantone Am</li>
<li>2021 – Fifty Cent Piece</li>
</ul>
<p class="wp-block-paragraph"><strong>Stall Tilly (2)</strong></p>
<ul class="wp-block-list">
<li>1991 – Noble Tilly</li>
<li>2014 – Noble Tilly</li>
</ul>
<p class="wp-block-paragraph"><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 class="wp-block-paragraph"><strong>W. Horse AB, Enskede (2)</strong></p>
<ul class="wp-block-list">
<li>2009 – Yield Boko</li>
<li>2010 – Yield Boko</li>
</ul></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>
