
<p class="has-drop-cap wp-block-paragraph">Han klev fram som den store Derbyfavoriten efter att ha satt nytt världsrekord vid vinsten i Eskilstunas Fyraåringstest i juli på 1.11,0a/2.640 meter. Daniel Wäjerstens toppfyraåring <strong>Zarex</strong> (e. Readly Express) väntar dock fortfarande på den stora fullträffen. Största segrarna har kommit i nämnda fyraåringstest och dubbla Breeders Crown-semifinaler, men i Derbyt fick han nöja sig med fjärdeplatsen.</p>



<p class="wp-block-paragraph">För Zarex del väntar hästens sjunde stora unghästfinal. Som treåring var han finalist i Kriteriet, Breeders Crown och båda E3-finalerna med femteplatsen i Breeders som främsta resulatat. I år har han förutom Derbyt även kvalat in till Kungapokalen.</p>



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



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



<ol class="wp-block-list">
<li><strong>Cold Blaze</strong> (e. Sebastian K.) – Carl Johan Jepson (Mattias Djuse)</li>



<li><strong>Recycle Cash</strong> (e. Ready Cash) – Magnus A Djuse (Mattias Djuse)</li>



<li><strong>Ejnar Face</strong> (e. Mosaique Face) – Adrian Kolgjini</li>



<li><strong>Zarex</strong> (e. Readly Express) – Daniel Wäjersten</li>



<li><strong>Gap Kronos</strong> (e. Face Time Bourbon) – Örjan Kihlström (Daniel Wäjersten)</li>



<li><strong>Gumshoe Sox</strong> (e. Gu d&#8217;Heripre) – Mats E Djuse (Daniel Wäjersten)</li>



<li><strong>Don Gaagaa</strong> (e. Googoo Gaagaa) – Ole Johan Östre (Ulf Stenströmer)</li>



<li><strong>Jonte Godiva</strong> (e. Who&#8217;s Who) – Ulf Ohlsson (Markus Pihlström)</li>



<li><strong>Raphael</strong> (e. Mosaique Face) – Rikard N Skoglund (Fredrik Wallin)</li>



<li><strong>Joker Ima</strong> (e. Bold Eagle) – Peter G Norman</li>



<li><strong>Sven Kuce</strong> (e. Readly Express) – Gustav Johansson (Thomas Madsen)</li>



<li><strong>Lugano Cortina</strong> (e. Green Manalishi) – Björn Goop</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/07/miladyjosselyn-1-617x333.jpg" alt="" class="wp-image-875062"/><figcaption class="wp-element-caption">Lutfi Kolgjini-tränade Milady Josselyn och Adrian Kolgjini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Ett nytt namn kommer att skriva in sig i historieböckerna för svenska ston födda 2022. I BC-finalen finns nämligen ingen av kullens tidigare storloppsvinnare med.</p>



<p class="wp-block-paragraph">Däremot finns det gott om finalplatser i unghästfinaler bland deltagarna, där två av finalisterna är dubbelmiljonärskor: <strong>Love To The Limit</strong> och <strong>Global Got It All.</strong> Den förstnämnda har andraplatsen i korta E3 som främsta merit, medan Global Got It All var trea i samma E3-final och dessutom tvåa i korta E3.</p>



<p class="wp-block-paragraph">Från Stochampionatets final är <strong>Milady Josselyn, Jiovanha Falkone</strong> och <strong>Love To The Limit</strong> med. Milady Josselyn lyckades bäst på Axevalla med fjärdeplatsen.</p>



<p class="wp-block-paragraph">Från treåringarnas största lopp Oaks är det bara <strong>Timotejs Online</strong> som kvalat in till BC-final drygt ett år senare.</p>



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



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



<ol class="wp-block-list">
<li><strong>Jiovanha Falkone</strong> (e. Don Fanucci Zet) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Milady Josselyn</strong> (e. Ready Cash) – Dante Kolgjini (Lutfi Kolgjini)</li>



<li><strong>Love to the Limit</strong> (e. Bold Eagle) – Björn Goop</li>



<li><strong>Chamberi</strong> (e. Readly Express) – Magnus A Djuse (Timo Nurmos)</li>



<li><strong>Time To Run</strong> (e. Who&#8217;s Who) – Claes Sjöström</li>



<li><strong>Jacqueline Zet</strong> (e. Googoo Gaagaa) – Carl Johan Jepson (Daniel Redén)</li>



<li><strong>Nyharajah</strong> (e. Maharajah) – Thomas Dalborg (Henrik Nyberg)</li>



<li><strong>Preposterous</strong> (e. Don Fanucci Zet) – Johan Untersteiner</li>



<li><strong>Timotejs Online</strong> (e. Face Time Bourbon) – Per Linderoth (Björn Goop)</li>



<li><strong>Drag Racing</strong> (e. Amaru Boko) – Jenny Brunzell (Jan Hellstedt)</li>



<li><strong>Global Got It All</strong> (e. Walner) – Rikard N Skoglund (Fredrik Wallin)</li>



<li><strong>Olympia Sting</strong> (e. Maharajah) – Mats E Djuse (Claes Sjöström)</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/2026/11/11recyclecash-617x333.jpg" alt="" class="wp-image-917332"/><figcaption class="wp-element-caption">Recycle Cash och Magnus A Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Mattias Djuse har fyra finalister totalt och på fyraåringssidan duon <strong>Cold Blaze</strong> (e. Sebastian K.) och storloppsspecialisten <strong>Recycle Cash</strong> (e. Ready Cash), som inleder från de två innersta spåren.</p>



<p class="wp-block-paragraph">Recycle Cash har haft en stark säsong utan att få vinna något riktigt stort och kan sätta pricken över i:et i sista unghästfinalen. Redan ifjol slutade hästen tvåa i både korta E3-finalen och Breeders Crown och i år ha. han kvalat in till Kungapokalen och Europaderbyt – trea i båda finalerna – innan han nu är redo för BC-final.<br>– Recycle Cash har väldigt fin form och är bra häst. Han gjorde ett jättebra lopp senast och jag hoppas att han kan göra om det i finalen. Han brukar hitta bra form på höstkanten, sade Magnus A Djuse till ATG Live.</p>



<p class="wp-block-paragraph">Tränare Mattias lämnar positiva besked.<br>– Hästarna gick sina sista jobb i torsdags och allt var som det skulle. Cold Blaze testades med rycktussar i måndags och det föll väl ut och kändes pigg på bra sätt i torsdagens jobb, sade han till ATG Live.</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/2026/11/3chamberi-617x333.jpg" alt="" class="wp-image-917280"/><figcaption class="wp-element-caption">Chamberi och Magnus A Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Minst rutinerad bland de fyraåriga stona är Timo Nurmos-tränade <strong>Chamberi</strong> (e. Readly Express), som sina fyra år till trots bara hunnit med nio starter så här långt. Att det är en talang utöver det vanliga råder inga tvivel om – hon av vunnit åtta av nio starter och är obesegrad i årets fem framträdanden.</p>



<p class="wp-block-paragraph">Tränaren Timo Nurmos delar andraplatsen i tränarligan i Breeders Crown med Robert Bergh på åtta segrar, fyra bakom överlägsne ledaren Daniel Redén.<br>– Hon har någonting extra, det är en otroligt fin häst rakt igenom och känns att det är något extra man sitter bakom. Jag har inte bestämt hur jag vill lägga upp det, det finns mer startsnabbhet att ta fram, men att spetsa blir svårt ändå. Jag har en bra häst, så jag tror att vi kan köra på olika sätt och ändå vara med där framme, sade Magnus A Djuse till ATG Live.</p>



<p class="wp-block-paragraph">Timo Nurmos både äger och är uppfödare till Chamberi.</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/2026/11/dragracing-617x333.jpg" alt="" class="wp-image-921471"/><figcaption class="wp-element-caption">Jan Hellstedt-tränade Drag Racing och Jenny Brunzell. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Breeders Crown ingår i premiechansen och hästar som ingår där tävlar om 50 procent extra i prispengar. Det gäller 21 av de 24 hästarna i fyraåringarnas final.</p>



<p class="wp-block-paragraph">De som står utanför är tyskfödde <strong>Lugano Cortina</strong> (e. Green Manalishi) på hingstsidan och <strong>Time To Run</strong> (e. Who’s Who) och <strong>Drag Racing</strong> (e. Amaru Boko) på stosidan.</p>



<p class="wp-block-paragraph"><strong>Priser för premiechansade hästar:</strong><br>1.200.000-600.000-300.000-144.000-96.000-60.000 kr</p>



<p class="wp-block-paragraph"><strong>Priser för icke premiechansade och utländska hästar: </strong><br>800.000-400.000-200.000-96.000-64.000-40.000 kr</p>



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



<p class="has-drop-cap wp-block-paragraph">Fyraåringarna går in i den sista, stora unghästfinalen innan de ska försöka ta sig in i den äldre eliten kommande säsonger med i flera fall välfyllda bankböcker. Hittills har finalisterna tjänat 34.014.570 kronor, eller 1.417.273 kronor i snitt.</p>



<p class="wp-block-paragraph">De siffrorna räcker dock inte mot de ett år yngre travarna i BC-finalerna. Treåringarna har nämligen hittills samlat ihop 36.009.515 kronor (snitt: 1.5600.396 kr).</p>



<p class="wp-block-paragraph">Hingstarna och valackerna har tjänat tre miljoner mer än stona. 18.578.572 kronor (1.548.214 kronor i snitt) mot de fyraåriga stonas inkomst 15.435.998 kronor (1.286.333 kronor 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/2024/09/gapkronosasm240926adamstromstalltz-617x383.jpg" alt="" class="wp-image-639593"/><figcaption class="wp-element-caption">Svenskfödde Gap Kronos vid seger för Åke Svanstedt i Lexington som tvååring. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">En miljonhäst finns bland de fyraåriga finalisterna, Winged Lion Breeding AB sålde <strong>Gap Kronos</strong> på ITS-auktionen i Italien för tre år sedan för 105.000 euro. Köpare var Bruni Racing Team AB – och bakom båda stallen står italienaren Renato Bruni. Han äger dock numera bara en del i Gap Kronos som har fler delägare.</p>



<p class="wp-block-paragraph">Renato Bruni äger eller har ägt många travare av hög klass det senaste decenniet. Förra året vann exempelvis hans <strong>Far Wise As</strong> (e. Face Time Bourbon) Sprintermästaren. Denne vann också E3-final vilket även <strong>Dea Grif</strong> (e. Varenne) lyckades med.<br>Duon är italienskfödd, men med svenskfödda travare firade han framgångar med fyrfaldiga miljonärskan <strong>Vamp Kronos</strong> (e. Ready Cash). Annars är Brunis största stjärnor två hästar han delägt, <strong>Vivid Wise As </strong>och <strong>Face Time Bourbon</strong>! </p>



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



<ul class="wp-block-list">
<li>Preposterous – Solvalla Yearling Sale – 360.000 kr</li>



<li>Love Ti The Limit – Solvalla Yearling Sale – 340.000 kr</li>



<li>Timotejs Online – Criterium Sale – 180.000 kr</li>



<li>Jiovanha Falkone – Criterium Sale – 100.000 kr</li>
</ul>



<p class="wp-block-paragraph"><strong>Fotnot: Nyharajah</strong> ropades åter på Elitauktionen för 200.000 kronor. <strong>Olympia Sting</strong> var återrop för 50.000 kronor på Next Generation Sale. <strong>Drag Racing</strong> bjöds ut som treåring på Travera 2025 och ropades åter för 270.000 kronor.</p>



<p class="wp-block-paragraph"><strong>Auktionspriser – fyraåriga hingstar/valacker: </strong></p>



<ul class="wp-block-list">
<li><strong>Gap Kronos</strong> – ITS Yearling Sale – 105.000 euro</li>



<li><strong>Joker Ima</strong> – Next Generation Sale – 160.000 kr</li>



<li><strong>Gumshoe Sox</strong> – Solvalla Yearling Sale – 140.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/2026/11/jacquelinezet-617x333.jpg" alt="" class="wp-image-921475"/><figcaption class="wp-element-caption">Daniel Redén-tränade Jacqueline Zet och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Brixton Medical blev Stall Zet AB som uppfödarpseudonym och i Breeders Crown-sammanhang har det blivit tre uppfödarvinster. Den första kom redan 2015 när tränaren Daniel Redén själv lotsade <strong>Trinity Zet</strong> (e. S.J.’s Photo) till vinsten i finalen för de fyraåriga stona.</p>



<p class="wp-block-paragraph">I årets BC-finaler har Stall Zet två uppfödningar till start och förutom <strong>Kodiak Zet</strong> bland de treåriga hingstarna och valackerna, så kan <strong>Jacqueline Zet</strong> (e. Googoo Gaagaa) gå i Trinity Zets hovspår i finalen för de fyraåriga stona.</p>



<p class="wp-block-paragraph">Och vill Jacqueline Zet veta hur man gör för att vinna en BC-final kan hon fråga storebror <strong>Francesco Zet</strong> (e. Father Patrick). Denne tillhör skaran hästar som dubblat i Breederssammanhang med vinst både som treåring och fyraåring.<br>– Jacqueline Zet var klart bättre än jag vågat hoppats på senast då hon återkom efter långt uppehåll på grund av halsproblem. Hon blev hängande från början men hade ändå spurtkrutet torrt över upploppet och det var mycket glädjande att se. Hon kommer gå framåt en hel del med loppet och hon kan öppna över medel från start. Barfota runt om och bike, säger Daniel Redén på sin hemsida <a href="http://reddis.se">reddis.se</a>.</p>



<p class="wp-block-paragraph"><strong>Uppfödare med två eller fler vinnare: </strong></p>



<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 </li>



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



<p class="wp-block-paragraph"><strong>Brodda Stuteri (3)</strong></p>



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



<li>2022 – Dancer Brodde</li>



<li>2024 – Daim Brodda</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>Stall Zet AB, Örsundsbro (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>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 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>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 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 &#038; J-E Magnusson (2)</strong></p>



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



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



<p class="wp-block-paragraph"><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 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>



<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/2026/10/6gumshoesox-617x333.jpg" alt="" class="wp-image-908189"/><figcaption class="wp-element-caption">Gumshoe Sox och Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Fakta Breeders Crown fyraåriga hingstar/valacker</h2>



<p class="wp-block-paragraph"><em>Häst – Uppfödare – Ägare – Skötare</em></p>



<ol class="wp-block-list">
<li><strong>Cold Blaze</strong> – Knutsson Trotting AB, Göteborg – Stall Table 609 – Petra Lindberg</li>



<li><strong>Recycle Cash</strong> – Wijs Bone AB &#038; Capital R1 Sub3 AB – Stall Dalhem – Victor Remneby</li>



<li><strong>Ejnar Face</strong> – Lutfi Kolgjini &#038; Anna Svensson – Karin Walter-Mommert, Tyskland – Josefin Sandkvist</li>



<li><strong>Zarex</strong> – Falconeri Racing Stable HB, m fl – Executive Caviar Racing Stable HB, m fl – Ida Edin</li>



<li><strong>Gap Kronos</strong> – Winges Lion Breeding AB, Bjärred – Bruni Racing Team AB, m fl – Janika Häggman</li>



<li><strong>Gumshoe Sox</strong> – Joakim Boholm &#038; Craig Mitchell – Stall Bella Ciao-Ofcourse – Lova Lindberg</li>



<li><strong>Don Gaagaa</strong> – Sign Design Väst AB &#038; Pia Ivehag – Sign Design Väst AB, Sjuntorp – William Johansson</li>



<li><strong>Jonte Godiva</strong> – Godiva AB, Bjärred – Tie HB, Sundsvall – Minnah Söderlund</li>



<li><strong>Raphael</strong> – Mårten Bergström, Visby – Easy KB, Uppsala – Matilda Bergström</li>



<li><strong>Joker Ima</strong> – Ingemar Alin, Ljusdal – NeGo Sverige AB, Uppsala – Adam Hanley</li>



<li><strong>Sven Kuce</strong> – Curt-Olof &#038; Cecilia Dahl – Stall Sven Kuce-Asap – Frida Borg</li>



<li><strong>Lugano Cortina</strong> – Sonja Wewering, Tyskland – Cortina Wewering AB, Karlstad – Jessica Schade Lundell</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/11/2lovetothelimit-617x333.jpg" alt="" class="wp-image-917275"/><figcaption class="wp-element-caption">Love To The Limit och Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Fakta Breeders Crown fyraåriga ston</h2>



<p class="wp-block-paragraph"><em>Häst – Uppfödare – Ägare – Skötare</em></p>



<ol class="wp-block-list">
<li><strong>Jiovanha Falkone</strong> – Ulf Lindström, Luleå – Stall Zet (Daniel Redén) – Carolina Persson</li>



<li><strong>Milady Josselyn</strong> – S.C.E.A. Ecurie Bernard Yvan, m fl – Lutfi Kolgjini AB, Veberöd – Jessy van den Berg</li>



<li><strong>Love to the Limit</strong> – Mike Lenders, Frankrike – Stall FG-Ofcourse – Iida Lind</li>



<li><strong>Chamberi</strong> – Stall Timo Nurmos AB, Tullinge – Stall Timo Nurmos AB, Tullinge – Inga Perk</li>



<li><strong>Time To Run</strong> – Caroline Jansson, Vallentuna – Stall Caroline Jansson AB, Vallentuna – Anna Hell</li>



<li><strong>Jacqueline Zet</strong> – Stall Zet AB (Daniel Redén), Örsundsbro – Stall Zet (Daniel Redén) – Joline Kjellstrand</li>



<li><strong>Nyharajah</strong> – Cecilia &#038; Henrik Nyberg – Nygårdens Stuteri &#038; Veterinär AB, Varnhem – Erik Nyberg</li>



<li><strong>Preposterous</strong> – Östen Carlsson, Stockholm – Hjelte Restaurang AB, m f – Matleena Kuitunen</li>



<li><strong>Timotejs Online</strong> – Mona Elsert &#038; Hans Östberg – Karin Walter-Mommert, Tyskland – Iida Lind</li>



<li><strong>Drag Racing</strong> – Stall Gustafsberg AB, Västervik – Jan Hellstedt, Gränna – Jenny Brunzell</li>



<li><strong>Global Got It All</strong> – Global Farm AB, Nacka – Stall MajKen HB, m fl (Fredrik Wallin) – Matilda Bergström</li>



<li><strong>Olympia Sting</strong> – Elisabeth, Olof &#038; Karl Sandström – Stall Masby-Easy – Johanna Johansson</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/2025/05/ejnarface-617x333.jpg" alt="" class="wp-image-725263"/><figcaption class="wp-element-caption">Ejnar Face och Adrian Kolgjini på Jägersro. </figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Tyska miljardärskan Karin Walter-Mommert är Sveriges största hästägare när det gäller tävlingshästar. Hela 379 hästar finns hos svenska proffstränare och av dessa startar fyra i Breeders Crown-finalerna, en i varje klass.</p>



<p class="wp-block-paragraph">På fyraåringssidan är miljonärerna <strong>Ejnar Face</strong> (e. Mosaique Face) och <strong>Timotejs Online</strong> (e. Face Time Bourbon) Walter-Mommerts hopp, medan hon bland treåringarna mönstrar Oakstvåan <strong>Global Halo</strong> (e. Ready Cash) och <strong>Vancouver Tile</strong> (e. Walner).</p>



<p class="wp-block-paragraph">Karin Walter-Mommerts största seger som hästägare på svensk mark kom för fem år sedan när hennes då nyinköpte <strong>Tetrick Wania</strong> (e. Muscle Hill) vann Svensk Uppfödningslöpning i sin öppfödare och tidigare ägare Riina Rekiläs regi.</p>



<p class="wp-block-paragraph"><strong>Hästägare med två eller fler vinnare: </strong></p>



<p class="wp-block-paragraph"><strong>Stall Zet (9)</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>



<li>2025 – Perfect Chest</li>
</ul>



<p class="wp-block-paragraph"><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 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>Anders van Dapperen AB (2)</strong></p>



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



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



<p class="wp-block-paragraph"><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 class="wp-block-paragraph"><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 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>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 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>



<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="g3Lj2OsLdi"><a href="https://sulkysport.se/bc-stjarntatt-bland-trearingarna/">BC: Stjärntätt bland treåringarna</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”BC: Stjärntätt bland treåringarna” – Sulkysport" src="https://sulkysport.se/bc-stjarntatt-bland-trearingarna/embed/#?secret=MQtkBc6UfO#?secret=g3Lj2OsLdi" data-secret="g3Lj2OsLdi" 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="25MosBzBnF"><a href="https://sulkysport.se/bc-kung-utan-finalister/">BC-kung utan finalister</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”BC-kung utan finalister” – Sulkysport" src="https://sulkysport.se/bc-kung-utan-finalister/embed/#?secret=SKO1nz7MKZ#?secret=25MosBzBnF" data-secret="25MosBzBnF" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
