
<p class="has-drop-cap wp-block-paragraph">1På lördag är det premiär för de nya propositionerna för STL-lopp, där bland annat klass III gör comeback som lägsta klass. Dessutom är de två lägsta klasserna förbehållna svenskfödda hästar.</p>



<p class="wp-block-paragraph">En annan återkomst är dubbelklasslopp och Romme bjuder på klass II mot bronsdivisionen på lördag. I dessa lopp startar högst sju hästar på varje volt och inga deltagarna kan därmed få bakspår.<br>– Tränare säger att de i större utsträckning skulle anmäla till ett lopp där man är garanterad framspår vilket skulle öka kvaliteten på loppet och spelare tror att det skulle kunna bli mer körning i loppet om alla hästar har framspår och med möjlighet att ladda för en bra position, skrev ST:s propositionsskrivare Mattias Stenby i samband med att dubbelklassloppen presenterades tidigare.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/12/21v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens V75-tävlingar på Romme.</a></p>



<p class="wp-block-paragraph"><strong>Så här ser de nya rikstotoklasserna ut från och med på lördag:</strong></p>



<ul class="wp-block-list">
<li><strong>Klass III:</strong> 3-åriga och äldre svenska 75.001-175.000 kr.</li>



<li><strong>Klass II:</strong> 3-åriga och äldre svenska 150.001-300.000 kr.</li>



<li><strong>Klass I:</strong> 3-åriga och äldre 200.001-550.000 kr.</li>



<li><strong>Bronsdivisionen: </strong>3-åriga och äldre 400.001-950.000 kr.</li>



<li><strong>Silverdivisionen:</strong> 3-åriga och äldre 550.001-1.800.000 kr.</li>



<li><strong>Gulddivisionen: </strong>3-åriga och äldre lägst 950.001 kr.</li>



<li><strong>Stodivisionen:</strong> 3-åriga äldre svenska ston upp till 750.000 kr (varierande klasser).</li>



<li><strong>Diamantstoet:</strong> 3-åriga och äldre ston lägst 300.001 kr (varierande klasser).</li>



<li><strong>Kallblodsdivisionen:</strong> 3-åriga och äldre svenska och norska kallblodiga (varierande klasser).</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/2019/04/v75genre-617x333.jpg" alt="trav, travsport, sulkysport, atg, ekonomi" class="wp-image-42583"/><figcaption class="wp-element-caption">ATG laddar för multijackpot på V75. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">215,3 miljoner kronor finns kvar i ATG:s fond med bunkrade vinstpengar för V75, men nu kommer åtta chanser att fylla på potten. Hela – eller delar av dem – ska sedan delas ut i en multijackpot på V75 på Axevalla på nyårsafton.</p>



<p class="wp-block-paragraph">Lördagen är startskottet för den nya insamlingen och alla eventuella jackpotpengar på V75 från den 21 till 30 december läggs in i fonden. <br>– Vi hoppas kunna erbjuda en Drömjackpot med 75 miljoner till en ensam vinnare på nyårsafton, men där är vi inte än utan vad det blir till slut beror på jackpotutfallet fram till dess, säger Petter Johansson, chef för hästspelen på ATG, i ett pressmeddelande.</p>



<p class="wp-block-paragraph"><strong>V75-schemat i jul och nyår:</strong></p>



<ul class="wp-block-list">
<li>21 december – Romme</li>



<li>23 december – Eskilstuna</li>



<li>25 december – Umåker</li>



<li>26 december – Solvalla</li>



<li>27 december – Momarken</li>



<li>28 december – Halmstad</li>



<li>29 december – Ålborg</li>



<li>30 december – Bjerke</li>



<li>31 december – Axevalla</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">3En Kriteriefinalist med imponerande seger i första starten efter det klassiska loppet och en jämngammal utmanare som ståtar med fyra raka segrar. Det blir ett intressant möte mellan <strong>Bäcklös Tili</strong> (e. Horgen Tore) och <strong>B.W.Birger</strong> (e. Tekno Odin) i ett treåringslopp med 50.000 kronor i förstapris i Gävle (första start 18.20) ikväll.<br>Oskar Kylin Blom tränar den förstnämnde som är lillebror till <strong>Bäcklös Uriel</strong> (e. Smedheim Solan) och <strong>Bäcklös Faron</strong> (e. Järvsö Tore), medan B.W.Birger kommer från Jan-Olov Perssons stall.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/redhotroadster-617x333.jpg" alt="" class="wp-image-509096"/><figcaption class="wp-element-caption">Emma-Sara Sjöbergs Dark Roadster och Ida Riesterer tangerade världsrekordet för äldre hingstar och valacker ifjol. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">15 hästar på tre volter möts i ett B-tränarlopp och bland dessa finns flera starka namn. Som Emma-Sara Sjöbergs <strong>Dark Roadster</strong> (e. Super Photo Kosmos), som förra året tangerade världsrekordet över sprinterdistans med voltstart, men väntar på första segern sedan 23 december förra året.<br>Ännu längre har unghäststjärnan <strong>Shocking Superman</strong> (e. Orlando Vici) väntar på att besöka vinnarcirkeln. Det skedde i juni 2021. Numera tränas hästen av Sofia Johansson och har ett lopp i kroppen efter efter över tre års tävlingsuppehåll.</p>



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



<p class="has-drop-cap wp-block-paragraph">4Halmstad (start 12.20) inleder tisdagen på svensk mark med lunchtävlingar och Åbytränaren André Eklundh reser söderut med <strong>Mr Shyguy</strong> (e. Adrian Chip).</p>



<p class="wp-block-paragraph">Hästen har haft en strålande höst efter tränarbyte och flytt till Eklundh. Fem satrter har slutat med fyra segrar och dessutom en tredjeplats i ett klass II-försök inom rikstoton.<br>Mr Shyguy kommer närmast från två raka triumfer på Solvalla i försök till Solvallaserien, men Eklundh valde start i en delningsproposition istället för finalen som körs i morgon på Solvalla.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/12/241217.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Ultrastammade <strong>Wall of Moni</strong> (e. Walner), 1.10,7am/682.947 NOK, med självaste <strong>Moni Maker</strong> som mormor gjorde fem starter som tvååring på andra sidan Atlanten 2021 innan han köptes till Norge. Först i maj förra året som fyraåring var han tillbaka på banan, men nu är tävlingskarriären över.</p>



<p class="wp-block-paragraph">Hästen flyttades från Frode Hamre till Geir Vegard Gundersen i september, men det blev aldrig något start i nya regin.<br>– Han var halt när han kom till oss och röntgen visade att en skruv som satts in i hovbenet (opererades i USA innan export till Norge, reds. anm.) hade lossnat. Vi fick honom haltfri, men att tävla igen är inte aktuellt, säger Geir Vegard Gundersen till Trav- og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Totalt blev det 16 starter (8-2-2) i Frode Hamres regi. Största segern togs i ett klass I-försök på Bjerke i mars och det följdes upp med tredjeplatsen i finalen under Elitloppshelgen på 1.10,7a/2.140 meter där <strong>Need’em</strong> (e. Propulsion) vann före blivande norske Derbyvinnaren <strong>Charron</strong> (e. Code Bon).</p>



<p class="wp-block-paragraph">Nu väntar avelsarbete för hingsten och uppstallning i Norge.</p>



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



<p class="has-drop-cap wp-block-paragraph">6Nordiska antidopingkommittén NEMAC förlänger karenstiden för antibiotika från minst åtta till minst 14 dygn. Detta gäller från och med 1 februari nästa år, <a href="https://www.travsport.se/arkiv/notiser/2024/december/forlangd-karenstid-for-vissa-antibiotika-fran-den-1-februari-2025/" target="_blank" rel="noreferrer noopener">skriver Svensk Travsport</a>.</p>



<p class="wp-block-paragraph">De läkemedel som berörs som är inregistrerade för häst i Sverige eller annat skandinaviskt land är sådana som innehåller bensylpenicillin, gentamicin, oxitetracyklin samt trimetoprim i kombination med sulfadiazin eller sulfadoxin.</p>



<p class="wp-block-paragraph"><em>”Bakgrunden är bland annat att val av antibiotikum ska ske enligt Läkemedelsverkets rekommendationer och inte utifrån hur lång karenstiden för tävling är. I dagsläget ses en generell nordisk och europeisk ökning i bruket av vissa antimikrobiella läkemedel som inte primärt ska användas som förstahandsval. Hästar som bedöms så sjuka att de av veterinär ordineras allmänbehandling med antibiotika ska, innan de åter kan anses vara i tävlingsmässigt skick, få tillräcklig tid för att återhämta sig,” </em>skriver ST om beslutet.</p>



<p class="wp-block-paragraph">Undantag gäller för lokalbehandling med läkemedel innehållande antibiotikasubstanserna kloramfenikol, fusidinsyra eller klortetracyklin är oförändrat och dessa har fortsatt minst 96 timmars karenstid för tävling.</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/07/charron-617x347.jpg" alt="" class="wp-image-605632"/><figcaption class="wp-element-caption">Charron. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Norska avelsföreningen <a href="https://www.travavl.no/" target="_blank" rel="noreferrer noopener">Travavl.no</a> har utsett årets bästa norskfödda häst. Utmärkelen ”Årets Made In Norway” gick till Geir Vegard Gundersen-tränade <strong>Charron</strong> (e. Code Bon), 1.10,6am/2.370.643 kr, som blev första häst någonsin att vinna norska ”triple crown” med triumfer i Jarlsberg Grand Prix, norska Derbyt och Axel Jensens Minneslopp.<br>Charron satte norskt rekord vid segern i norska Derbyt, som han tog hem på 1.13,0a/2.600 meter.</p>



<p class="wp-block-paragraph">Morten Langli är både ägare och uppfödare till fyraåringen, som vann sex av elva starter i år och tjänade över två miljoner norska kronor.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Dubbelklasslopp utan bakspår
Premiär för nya STL-propositionerna. ATG startar insamling till multijackpot på nyårsafton. Toppstammad femåring tvingas sluta. Nya karenstider för antibiotika.
Detta och mer i tisdagens nyhetssvep.
