
<p class="has-drop-cap">1 När <strong>Valorous</strong> (e. Alrajah One-Venerable) klubbades för 575.000 dollar på Lexington Selected Yearling Sale i förra veckan blev han den dyraste ettåringen efter en europafödd avelshingst på en auktion i Nordamerika.</p>



<p>Genom årens lopp har det sålts 36 ettåringar för 100.000 dollar eller mer och vars fäder är födda i Europa. Näst dyrast är en dotter till Revenue och D. Train vid namn <strong>D. Liteful Hanover</strong> nådde hela 325.000 dollar i Harrisburg 2007.</p>



<p>Green Manalishi har flest 100.000-dollartravare av samtliga avelshingstar från Europa. Efter den svenskfödde hingsten har det sålts nio travare som kostat sexsiffrigt och dyrast är <strong>Upgrade </strong>(u. Uptown Classic) för 300.000 dollar.</p>



<h2 class="wp-block-heading">Europafödda avelshingstar på auktioner i Nordamerika:</h2>



<p><strong>Avelshingst – Född – Antal – Högsta priset (år)</strong></p>



<ol class="wp-block-list">
<li><strong>Alrajah One </strong>– Italien – 1 – $575.000 (2025)</li>



<li><strong>Revenue</strong> – Sverige – 5 – $325.000 (2007)</li>



<li><strong>Green Manalishi</strong> – Sverige – 9 – $300.000 (2024)</li>



<li><strong>Ecurie D.</strong> – Danmark – 3 – $275.000 (2025)</li>



<li><strong>Ready Cash</strong> – Frankrike – 5 – $220.000 (2018)</li>



<li><strong>Love You </strong>– Frankrike – 3 – $220.000 (2023)</li>



<li><strong>Bold Eagle</strong> – Frankrike – 1 – $145.000 (2018)</li>



<li><strong>Face Time Bourbon</strong> – Frankrike – 3 – $140.000 (2022)</li>



<li><strong>Enjoy Lavec</strong> – Sverige – 3 – $135.000 (2003)</li>



<li><strong>Varenne </strong>– Italien – 1 – $125.000 (2005)</li>



<li><strong>Mr Lavec</strong> – Sverige – 1 – $110.000 (1998)</li>



<li><strong>Infinitif </strong>– Italien – 1 – $105.000 (2011)</li>
</ol>



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



<p class="has-drop-cap">2 På fredag – första utrop kl. 17.00 – hålls Criterium Sale på Kongressen på Solvalla och auktionskatalogen innehåller 125 hästar, varav sju är kallblod. Dagen innan (torsdag) finns det möjlighet att beskåda ettåringarna på Solvallas stallbacke mellan 10.00-17.00.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/skarmavbild20251006kl.10.16.48-350x437.jpg" alt="" class="wp-image-776208"/><figcaption class="wp-element-caption">På fredag är det dags för auktion på Solvalla.</figcaption></figure>



<p>Hela 51 avelshingstar finns representerade på auktionen och flest avkommor – elva vardera – har <strong>Calgary Games</strong> och <strong>Readly Express</strong>. Av fölstona på auktionen har 21 tjänat en miljon kronor eller mer. Tillsammans har fölstona lämnat 15 miljonärer och 29 fölston har sin första avkomma ute till försäljning.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/10/criteriumsale2025.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/10/criteriumsale2025.pdf" target="_blank" rel="noreferrer noopener">Katalogen till auktionen kan laddas ner här.</a></p>



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



<p class="has-drop-cap">3 Dagens huvudbana på svensk mark är <strong>Axevalla</strong> (start 18.20), där två av banans höstlöpningsserier står på programmet. Höstserien för treåringar når halvvägs med tredje försöket av sex och Maria Törnqvist tar ut ett av stallets ämnen. <strong>Kosing </strong>(e. International Moni) har inlett tävlingskarriären med två segrar och ett andrapris på tre starter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/tornqvistmaria240820adam-617x333.jpg" alt="" class="wp-image-628090"/><figcaption class="wp-element-caption">Maria Törnqvist. Foto Adam Ström/stalltz.se</figcaption></figure>



<p>– Det är en jättefin häst, som jag verkligen gillar. Han är bra redan nu, men kommer nog att blomma ännu mer nästa år. Han är väl förberedd inför detta och jag tror på en fin insats, säger Maria Törnqvist i Axevallas banprogram.</p>



<p>50.000 kronor väntar vinnaren i dagens försök. I finalen den 9 december ligger ytterligare 10.000 kronor i potten för vinnaren.</p>



<p>På nyårsafton avgörs finalen i Ecurie D:s stoserie, där vinnaren får både 100.000 kronor och en levande föl-avgift i Ecurie D. Första försöket körs ikväll och André Eklundh tar ut <strong>Ottens Lady Gaagaa</strong> (e. Googoo Gaagaa), som varit på pallen i sju av åtta starter.</p>



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



<p class="has-drop-cap">4 På lunchbanan <strong>Jägersro</strong> (första start 12.20) handlar de flesta loppen om en bred spårtrappa upp till tre miljoner intjänat. Dit har dagens deltagare en bra bit att vandra, men högsta klassen har samlat flera intressanta namn.</p>



<p>Carlos Söderström är tillbaka i tävlingsvagnen bakom sin topphäst <strong>Pingis</strong> (e. Bird Parker), som vann ett långlopp på Charlottenlunds Derbydag i näst senaste starten tillsammans med Stefan Persson. Tränare Söderström har inte kört Pingis sedan i juli, men nu är det alltså dags.</p>



<p>Pingis och Johan Untersteiners kapable sjuåring <strong>Smile Silvio</strong> (e. The Bank) inleder från bakspår, medan Joakim Lövgrens kapabla duo <strong>Gustav Simon</strong>i (e. Ready Cash) och fjolårets Kungapokalstvåa <strong>Remember Me D.E.</strong> (e. Maharajah) finns i främre ledet bakom startbilen.</p>



<p>Tisdagen kompletteras med breddlopp i <strong>Bollnäs</strong> (start 17.45). </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/10/251007.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/10/251007.pdf" target="_blank" rel="noreferrer noopener">Startlistorna hittar ni här. </a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/10/sixpackmlw-617x329.jpg" alt="Six Pack och Åke Svanstedt, Sulkysport" class="wp-image-31822"/><figcaption class="wp-element-caption">Six Pack och Åke Svanstedt vid segern i Kentucky Futurity. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="has-drop-cap">5 <a href="https://sulkysport.se/vinst-pa-lopningsrekord/" data-type="link" data-id="https://sulkysport.se/vinst-pa-lopningsrekord/" target="_blank" rel="noreferrer noopener">Emoticon Legacy </a>(e. Walner) travade 1.08,0/1.609 meter när han vann Kentucky Futurity ($500.000) i söndags på Red Mile och det är den näst snabbaste tiden i världen av en treåring. Bara en travare har avverkat en engelsk mil snabbare och 2018 vann Åke Svanstedt och <strong>Six Pack </strong>(e. Muscle Mass) Kentucky Futurity på 1.07,9.</p>



<h2 class="wp-block-heading">Snabbaste vinnartiderna av treåringar</h2>



<p><strong>Namn (kön/far) – Bana – År – Segertid</strong></p>



<ul class="wp-block-list">
<li><strong>Six Pack </strong>(h e. Muscle Mass) – Red Mile – 2018 – 1.07,9</li>



<li><strong>Emoticon Legacy</strong> (h e. Walner) – Red Mile – 2025 – 1.08,0</li>



<li><strong>Dancinginthedark</strong> (h e. Readly Express) – Red Mile – 2021 – 1.08,1</li>



<li><strong>Jujubee </strong>(h e. Creatine) – Red Mile – 2021 – 1.08,1</li>



<li><strong>Sig Sauer </strong>(h e. Muscle Hill) – Red Mile – 2014 – 1.08,1</li>



<li><strong>Go Dog Go </strong>(h e. Greenshoe) – Red Mile – 2025 – 1.08,1</li>
</ul>



<p><strong>Fotnot:</strong> Åke Svanstedts <strong>Plunge Blue Chip </strong>(e. Muscle Mass) är snabbaste treåriga sto och två gånger travade hon 1.08,2 på Meadowlands respektive Red Mile 2018. Samma år noterade också <strong>Impinktoo</strong> (e. Manofmanymissions) 1.08,2 i Lexington.</p>



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



<p class="has-drop-cap">6 <strong>Inexess Bleu</strong> startar i finalen i UET Elite Circuit och hästens ägare Michel Gallier ägde <strong>Jag de Bellouet</strong>. När hästen visade sig vara dopad vid sin ena seger i Prix d’Amérique flyttades <strong>Gigant Neo</strong> upp som vinnare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/gigantneoprismelanderpokal-617x394.jpg" alt="" class="wp-image-226791"/><figcaption class="wp-element-caption">Hederspriset från Prix d&#8217;Amérique. Foto: stalltz.se</figcaption></figure>



<p>Michel Gallier vägrade dock att ge ifrån sig hederspriset trots flera påstötningar och kommer han till Solvalla på lördag kan det vara läge (?) att ge hederspriset från Prix d’Amérique till Stefan Melander…</p>



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



<p class="has-drop-cap">7<strong> Valetta Strix </strong>(e. Going Kronos-Afrodite Sund), 1.10,9ak/1.176.959 kr, har inte varit lätt att få dräktig i år, men nu kan Ingemar Alin berätta att hon väntar föl nästa år efter Elitlopps- och Åby World Grand Prix-vinnaren Horsy Dream.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/skarmavbild20251006kl.10.51.38-617x595.jpg" alt="" class="wp-image-776210"/><figcaption class="wp-element-caption">Valetta Strixs årsföl efter Önas Prince.</figcaption></figure>



<p></p>



<p>I år har har hon blivit mor till en dotter efter Önas Prince (bilden) vid namn <strong>Michelle Ima</strong>. Valetta Strix tog sin största seger på fransk mark i Prix Madame Raymond Rigaul i Graignes och i Sverige vann hon Serenas lopp och även rikstotolopp.</p>



<p>Valetta Strix är helsyster med <strong>Valentino Strix </strong>(e. Going Kronos), 1.11,7am/1.948.209 kr, och i samma syskonskara ingår också <strong>Walmar E.W</strong>. (e. Maharajah), 1.11,5ak/707.300 kr.</p>
