
<p class="has-drop-cap">1Norges ledande kusk sett till antalet segrar är Eirik Höitomt och han är flitigt i elden under kvällens tävlingar på Bjerke (första start 18.38), där han går en hård match med Frode Hamre om banchampionatet. 52-51 är ställningen i Höitomts favör inför avslutningen, där Hamre dock har fler andrapris.</p>



<p>Höitomt tar i år sitt 15:e landschampionat som kusk i Norge. 2022 klev han förbi de tidigare dominanterna Ulf Thoresen och Gunnar Eggen, som stannade på 13 titlar vardera.</p>



<p>Tidigare i år, i februari, klev Höitomt upp i topp som segerrikaste norske kusk genom tiderna när han passerade mångårige ledaren Eggen.</p>



<p>54-årige Eirik Höitomt, som är född i Orre söder om Stavanger på norska sydvästkusten, tog sin första seger med <strong>Zmita Yankee Jeb</strong> (e. Frosted Yankee) på Forus 1987 och inledde tränarbanan på Sörlandet innan han för 20-talet år sedan sökte sig norrut till Jarlsberg.</p>



<p>Bland hans klassiska triumfer finns Derbyseger med <strong>Handboy </strong>2001 och med Makarov 2010, tre vinster i Stoderbyt (<strong>Madelen L.T.C, Valla d&#8217;Estino, Rita Tomali</strong>) och ifjol vinst i Kriteriet med <strong>Dyess</strong>.</p>



<p>Norges tränaretta Frode Hamre anlitar en hel del andra kuskar till sina hästar, men själv ståtar han med drygt 100 segrar på 354 starter och 29,4 i segerprocent som kusk i Norge. Platsprocenten är 66,4!</p>



<h2 class="wp-block-heading">Kuskligan i Norge 2023:</h2>



<ol class="wp-block-list">
<li>Eirik Höitomt, Jarlsberg – 1.416 st: 185-154-174 – 10.820.500 kr</li>



<li>Vidar Hop, Jarlsberg – 883 st: 135-106-107 – 8.856.000 kr</li>



<li>Åsbjörn Tengsareid, Jarlsberg – 1.102 st: 133-118-146 – 10.195.500 kr</li>



<li>Magnus Teien Gundersen, Bjerke – 761 st: 131-98-68 – 9.009.500 kr</li>



<li>Dag-Sveinung Dalen, Jarlsberg – 1.430 st: 130-177-162 – 7.620.750 kr</li>



<li>Svein Ove Wassberg, Bergen – 660 st: 108-73-90 – 5.095.000 kr</li>



<li>Tom Erik Solberg, Klosterskogen – 605 st: 108-73-90 – 9.239.500 kr</li>



<li>Frode Hamre, Jarlsberg – 354 st: 104-84-47 – 5.358.000 kr</li>



<li>Jomar Blekkan, Orkla – 307 st: 70-26-28 – 2.464.000 kr</li>



<li>Lars Anvar Kolle, Jarlsberg – 768 st: 67-91-79 – 5.878.500 kr</li>
</ol>



<p><em>Statistiken gäller starter på norska banor.</em></p>



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



<p class="has-drop-cap">2Bjerke är alltså spelplatsen för kvällens V75-omgång, där alla eventuella jackpotpengar förs vidare till multijackpotten på Axevalla på nyårsafton.</p>



<p>Den mest meriterade hästen som dyker upp är elvaårige valacken <strong>Chalimar de Guez</strong> (e. Nahar de Beval), som tränas av Frode Hamre. Han föll för åldersstrecket i Frankrike i mars och fick fortsätta sin karriär på nordisk mark. De största framgångarna har kommit under sadel och sedan han kom till Hamre har nio av tio starter (3-0-1) gjorts i monté. Bland annat slutade han trea i Paralympiatravsmontén på Åby i maj.</p>



<p>Ikväll blir det däremot sulky bakom och Lars Anvar Kolle sitter i vagnen, precis som vid enda starten i disciplnen i Hamreregi i augusti, där Chalimar du Guez gjorde bort sig med galopp. Bättre lycka denna gång?</p>



<p>Det sulkyloppet vanns av Hamres jänkare<strong> Type A.</strong> (e. Southwind Frank), som även finns med i kvällens lopp.</p>



<p>I onsdags segrade fjolårets Derbyvinnare <strong>Charleston Volo</strong> (e. Classic Photo) på Momarken och hästen är tillbaka på banan redan ikväll när han är med i samma snabblopp.</p>



<p>Blott två svensktränade hästar dyker upp i Bjerkes V75-lopp: <strong>Merci Bråten </strong>(V75-1), som tränas av Lars-Inge Olsson, och Tom Horpestads <strong>Embarrassed</strong> (V75-4).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/12/29v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Bjerkes V75-tävlingar.</a></p>



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



<p class="has-drop-cap">3Årets sista lunchtävlingar avgörs på Romme (första start 12.20) idag och en häst som kommit tillbaka fint efter långt uppehåll dyker upp. Det handlar om Lindesbergsamatören Lovisa Canneryds kallblod <strong>Ils Can</strong> (e. B.W.Modde), som vunnit tre lopp i år sedan han gjorde comeback i augusti efter två års tävlingsuppehåll. Sexåringen ståtar dessutom med två raka segrar tillsammans med Kenneth Gorski inför dagens start.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/magnusadjuse-617x333.jpg" alt="" class="wp-image-226449"/><figcaption class="wp-element-caption">Magnus A Djuse är på väg mot ett nytt banchampionat. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>När det gäller kuskchampionatet så tar Magnus A Djuse sin första titel på Romme. Det blir också 23-åringens femte championat 2023. Han har även tagit championatet på Solvalla, Eskilstuna, Lindesberg och Rättvik.</p>



<p>Tränartiteln går till Solvallas Jörgen Westholm, som kan dryga ut ledningen på en seger före tävlingsfrie Mattias Djuse ytterligare med sju starthästar idag.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/12/29v65.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Rommes tävlingar.</a></p>



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



<p class="has-drop-cap">4Efter två dagar utan blågula intressen på Vincennes (första start kl. 15.47) så ser det annorlunda ut denna fredag.</p>



<p>I Prix de Montauban (€56.000) för sjuåringar som högst tjänat 160.000 euro finns fyra svenskfödda hästar med i startlistan, men det är blott Jörgen Westholms Exodus Brick (e. Make It Happen) som är svensktränad.<br>Övriga bidrag är Jo Corbanies<strong> Silver Bullit </strong>(e. Orlando Vici), Jean Charles Pitons <strong>Musett af Djupmyra </strong>(e. Super Photo Kosmos) och Alessandro Gocciadoros Global Agreement (e. Love You).</p>



<p>Svenskt syns även i evakueringsloppet Prix de Sainte-Marie-du-Mont (€46.000) där Björn Goop kör Stefan Arvidsson-tränade <strong>G.K.Justus</strong> (e. Brad de Veluwe).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-12-29/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap">5Tidigare denna månad rapporterade vi om att Daniel Wäjersten fått in Eirik Djuve-ägda<strong> Dutchess Sun</strong> (e. Maharajah) 1.12,2am/503.300 kr i träning och nu har Bergsåkersproffset stärkt upp stallet med ytterligare ett meriterat förvärv ägt av Djuve.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/11/88takethissociety-617x463.jpeg" alt="" class="wp-image-55011"/><figcaption class="wp-element-caption">Take This Society när han såldes som ettåring. Foto: Lina Alm</figcaption></figure>



<p>Det handlar om den femårige Muscle Hill-sonen <strong>Take This Society</strong>, 1.10,4ak/800.530 kr som i Frode Hamres regi visat framhovarna på svensk mark tidigare.<br>Under fjolårets Elitloppshelg vann hingsten ett fyraåringslopp stängt vid 450.000 kronor på 1.11,5a/2.140 meter tillsammans med Erik Adielsson, men årets säsong har varit tuffare med blott två segrar på dussinet försök.</p>



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



<p class="has-drop-cap">6Hanna Lähdekorpi har utsetts av STaR och representera Sverige i Coupe Intercontinentle des Amateurs (€15.000) på Vincennes dagen före Prix d’Amérique. </p>



<p>Hanna Lähdekorpi har tackat ja till att deltaga i amartörloppet, vars svenska representant i år var Peter Arnqvist bakom Gloire de Feury som diskades för galopp. </p>



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



<p class="has-drop-cap">7I morgon startar treåriga stoet <strong>Outboard Display</strong> (e. Scarlet Knight) i E3-revanschen i Gävle med 150.000 kronor till vinnaren. Kanske gör hon det för en ny ägare? Ikväll bjuds hon nämligen ut till försäljning på ASVT:s internetauktion.</p>



<p>Outboard Display har vunnit ett lopp hittills i karriären och hennes amerikanska mamma <strong>Bell Bottom Blues</strong> (e. Muscles Yankee) är syster med miljonärerna <strong>Huis Clos</strong> (e. Bird Parker), som vann lopp på Vincennes dagen före julafton, och Ile Saint Louis (e. Credit Winner).</p>



<p>En starthäst, en tvååring efter Charly du Noyer och två fölston finns också med i kvällens digitala katalog.</p>



<p><a href="https://auktion.asvt.se/purchase" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som säljs och följa budgivningen under kvällen.</a></p>

Fokustema
Morgonsvepet
Läs senare
Vem är kung i Oslo?
Om den täta championstriden på norska nationalarenan Bjerke, flitigt med svenskhopp på Vincennes och ett meriterat nyförvärv hos Daniel Wäjersten går bland annat att läsa i fredagens morgonsvep.
