
<p class="has-drop-cap">1 En hingstandel i <strong>Face Time Bourbon</strong> såldes för 760.000 kronor på Travera-auktionen igår. En anonym köpare lade upp den summan, men det är inget rekord i Sverige för den dubble Prix d’Amérque-vinnaren.</p>



<p>2020 såldes en hingstandel i Face Time Bourbon på Yearling Sale för 1,8 miljoner och en vecka senare klubbades en andel på Travera för 1.350.000 kronor.</p>



<p>I december 2021 såldes ånyo en hingstandel i Face Time Bourbon på Menhammar Online Mixed Sale för 1.250.000 kronor och förra året kostade en andel i Ready Cash-sonen på Travera för 800.000 kronor.</p>



<p>Näst högsta priset betalade Ceorum AB för en sexårig valack. Prislappen blev 370.000 kronor för <strong>Itso Sisu</strong> (e. Bold Eagle-Karate Kate), 1.12,5am/613.300 kr, som vunnit nio av 33 starter och har tränats av Öystein Tjomsland.</p>



<p>Toppstammade kallblodet <strong>Brenne Blesa </strong>(e. Tekno Odin-Brenne Stjerna), 1.26,0k/1.662.605 kr, gick till Stall Kringeland Eriksen i Norge för 100.000 kronor. Hon har en startande avkomma i <strong>Arvaker Ess</strong> (e. Philip Ess), 1.32,3/19.248 nok.</p>



<p>Brenne Blesa vann stoavdelningen i Kallblodskriteriet i Norge, slutade tvåa i Kriteriestoet i Sverige och var tvåa i såväl det norska som svenska Stoderbyt. På 13 starter blev det sex segrar, tre andraplatser och två tredjepris under Öystein Tjomslands flagg.</p>



<p><a href="https://www.travera.nu/auktionsresultat/" data-type="link" data-id="https://www.travera.nu/auktionsresultat/" target="_blank" rel="noreferrer noopener">Samtliga resultat från Travera-auktionen hittar ni här.</a></p>



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



<p class="has-drop-cap">2 En spårtrappa för ston sticker ut för förhand på Grand Slam-75-banan <strong>Östersund</strong> (start 13.45) i eftermiddag. Dannerotränaren Micael Melander skadades illa och drabbades av blödningar i hjärnan i samband med en olycka i Bollnäs för knappt två veckor sedan. Idag årsdebuterar stallets kanske bästa häst med Micaels sambo Malin Viklund i sulkyn.</p>



<p>Det handlar om <strong>Mellby Interest</strong> (e. Explosive Matter), som tillsammans med Malin slutade tvåa i Dam-SM på Solvalla i oktober. Hon följde upp SM-silvret med fjärde årssegern på Umåker och gör nu första starten på nästan fyra månader.</p>



<p>Bland motståndarna finns <strong>Just More Fun</strong> (e. Super Photo Kosmos), som redan vunnit två lopp i år, och <strong>West Wind</strong> (e. Django Riff).</p>



<p>I ett lopp utanför GS75-kupongen årsdebuterar två V75-meriterade hästar från förra året. Hemmatränaren Oscar Berglunds <strong>No Limit Express </strong>(e. Readly Express) vann försök i både klass I och bronsdivisionen förra sommaren. Daniel Wäjerstens Readly Express-bror <strong>Kingslayer Pellini</strong> (e. Up And Quick) tog hem lärlings-SM tillsammans med Oskar Florhed och hade dessförinnan tre andraplatser i STL-lopp.</p>



<p>Söndagens tävlingar på svensk mark inleds med breddtrav i <strong>Halmstad</strong> (första stsrt 12.20).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/03/240317.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/03/240317.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap">3 Alessandro Gocciadoros unghäststjärna <strong>Funny Gio</strong> (e. Face Time Bourbon) vann fyra av sex lopp förra året och i första hand Grupp I-loppet Gran Premio Allevemento Masaf (€180.400) i Neapel. Idag årsdebuterar den treåriga travaren i stoavdelningen i Gran Premio Etruria (€37.400) i och det loppet drar till sig betydligt större intresse än hingstarnas uppgörelse.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/03/skarmavbild20240315kl.11.42.39.png" alt="" class="wp-image-561303"/></figure>



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



<p class="has-drop-cap">4 Åtta banor tävlar i Frankrike idag och på två av dessa dyker två svenska tränare upp. Ida Karlssons fyraåring <strong>Kapoceo</strong> (e. Coup de Poker) har inlett karriären med en tredjeplats och seger i den senaste starten – Prix d’Ouverture (€17.500) – i Amiens. Idag handlar det om Prix des Violettes (€17.500) i Graignes. Yoann Lebourgeois sitter i sulkyn över distansen 2.700 meter.</p>



<p><strong>Krystale Mayalou</strong> (e. Nuage de Lait) debuterar för Tomas Malmqvist i Prix Handi Cheval Mayenne (€13.500) i Meslay-du-Maine efter ha galopperat bort sig i debuten i juli förra året och då i regi ägaren Yann Jublot. Nu är det Tomas Malmqvist som tränar det fyraåriga stoet och Jublot sköter tömmarna i loppet över 2.875 meter.</p>



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



<p class="has-drop-cap">5 På Bjerke hölls det avelsvärdering i fredags och allra högst poäng erhöll <strong>Stoletheshow</strong> (e. Dream Vacation-Abba Hall), 1.09,5a/11.723.313 nok, vilken erhöll 86 av möjliga 100 poäng. Han fick omdömet ”mycket högt avelsvärde” och dagen efter – alltså igår – blev det seger i högsta klassen på <a href="https://sulkysport.se/v75-200-metersrokare-vi-minns/" data-type="link" data-id="https://sulkysport.se/v75-200-metersrokare-vi-minns/" target="_blank" rel="noreferrer noopener">Bjerke</a>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/stoletheshowdexterdunn-617x333.jpg" alt="" class="wp-image-452132"/><figcaption class="wp-element-caption">Stoletheshow tillsammans med Dexter Dunn på Solvalla. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Nedan hittar ni hingstarna som synades i Norge och till skillnad från den svenska avelsvärderingen så klumpas inte siffrorna ihop utan redovisas kategori för kategori, vilket också borde vara en självklarhet i Sverige.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/03/skarmavbild20240316kl.07.27.40.jpg" alt="" class="wp-image-561264"/><figcaption class="wp-element-caption">Resultat från avelsvärderingen i Norge. Tabellen hämtad från Trav-og Galopp-Nytt i Norge.</figcaption></figure>



<p><a href="http://www.travsport.no/aktuelt/2024/3/stoletheshow-dagens-hest/" data-type="link" data-id="http://www.travsport.no/aktuelt/2024/3/stoletheshow-dagens-hest/" target="_blank" rel="noreferrer noopener">Läs mer om den norska avelsvärderingen här.</a></p>



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



<p class="has-drop-cap">6 I fredags på Enghien avslöjade den skicklige montéjockyn David Thomain att han lägger ridstövlarna på hyllan efter 584 segrar, varav nio Grupp I-vinster och 35 titlar i semi-classque-löpningar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/01/davidthomainsulky-617x309.jpg" alt="" class="wp-image-17268"/><figcaption class="wp-element-caption">David Thomain. Foto Jeannie Karlsson/Sulkysport
Vincennes</figcaption></figure>



<p>– Det har funnits i mina tankar ett tag. Jag har skadat mig några gånger under de senaste tio åren. Om det beror på grund av min vikt, eller för att jag är ganska lång vet jag inte. Jag har inte heller haft några topphästar på ett tag och det är också mindre motiverande. För mig var det dags att fatta det här beslutet, sade David Thomain till ”24 au Trot.”</p>



<p>Största triumfen är enligt Thomains egen utsago första Prix de Cornulier-segern med <strong>One du Rib </strong>och dessutom tog han sin 1.000:e vinst med en sadelhäst. Sin senaste Grupp I-seger kom ovanpå <strong>J’Aime Le Foot</strong> i Saint-Leger des Trotteurs 2022 i Caen.</p>



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



<p class="has-drop-cap">7 Sulkysport har tidigare rapporterat om resultatet från avelsvärderingen för de hingstar som visades på <a rel="noreferrer noopener" href="https://sulkysport.se/hogst-poang-till-barack-face/" data-type="link" data-id="https://sulkysport.se/hogst-poang-till-barack-face/" target="_blank">Solvalla</a>. Nu har också värdeomdömen för de listade hingstarna blivit offentliggjorda från Svensk Travsport.</p>



<h2 class="wp-block-heading">Högt skattat avelsvärde: </h2>



<ul class="wp-block-list">
<li><strong>Etonnant </strong>(10 år e. Timoko-Migraine e. Alligator)<br><em>1.09,1ak/2.526.710 euro. 87 st: 22 segrar.</em><br><strong>Meriter: </strong>segrar i Elitloppet, Grand Criterium de Vitesse, Grand Prix de Wallonie, Kymi Grand Prix, Prix de l’Atlantique, Prix de Paris, Prix des Ducs de Normandie.<br><strong>Övrigt: </strong>verkat i aveln i Frankrike, första kullen föddes 2021 och har 126 registrerade avkommor. Tre i topp: <strong>Luxor de Villabon</strong> (€39.010), <strong>Lucky Sibey</strong> (€31.110) och <strong>Le Grand Zampano</strong> (€3.625).</li>
</ul>



<ul class="wp-block-list">
<li><strong>Krack Time Atout </strong>(4 år e. Face Time Bourbon-Topaze d’Atout e. Coktail Jet)<br><em>1.12,1l*/444.600 euro. 23 st: 5 segrar.</em><br><strong>Meriter:</strong> vinster i Prix de Berlin, Criterium des 3 ans och Prix Ourasi.</li>
</ul>



<ul class="wp-block-list">
<li><strong>Temporal Hanover </strong>(5 år e. Walner-Think Twice e. Cantab Hall)<br><em>1.08,4ak/972.166 dollar. 25 st: 9-8-2.</em><br><strong>Meriter: </strong>vinster i Champlain Stakes, Earl Beal Jr. Memorial, International Stallion Stakes, Zweig Memorial, tvåa i Kentucky Futurity och trea i Hambletonian Stakes.<br><strong>Övrigt: </strong>sattes i aveln 2023 och betäckte 137 ston i USA.</li>
</ul>



<ul class="wp-block-list">
<li><strong>Venerate </strong>(6 år e. Love You-Peaceful Kemp e. Muscle Hill)<br><em>1.08,5ak*/1.119.677 dollar. 40 st: 12-4-6.</em><br><strong>Meriter: </strong>segrar i Arthur J. Cutler Memorial, Kentucky Sire Stakes, Mohawk Million, tvåa i John Cashman Memorial samt finaltrea i Breeders Crown och Peter Haughton Memorial.</li>
</ul>



<h2 class="wp-block-heading">Medelmåttigt skattat avelsvärde:</h2>



<ul class="wp-block-list">
<li><strong>Born in the U.S.A.</strong> (11 år e. Muscle Hill-Christina Rose e. Chocolatier)<br><em>1.11,9am/2.059.414 nok. 15 st: 9-2-0.</em><br><strong>Meriter:</strong> vinster i Treåringsstjärnan, Hans Petter Tholfsens Minneslopp, Habibs Minneslopp och tvåa i Europaderbyt.<br><strong>Övrigt: </strong>verkat som avelshingst i Norge, första kullen föddes 2019 och har 114 registrerade avkommor. Tre i topp: <strong>Born In the Bergen</strong> (1.349.000 nok), <strong>Bunny</strong> (948.500 nok) och <strong>Olympic Winnner </strong>(424.850 nok)</li>
</ul>



<ul class="wp-block-list">
<li><strong>Volume Eight </strong>(4 år e. Chapter Seven-Lass A Rope e. Encore Encore)<br><em>1.09,6ak*/434.002 dollar. 10 st: 7-0-0.</em><br><strong>Meriter: </strong>segrar i International Stallion Stakes, Kindergarten Series och Valley Victory.</li>
</ul>
