
<p class="has-drop-cap wp-block-paragraph">1 Inte oväntat på något sätt – <strong>Propulsion</strong> är den mest populära avelshingsten i Finland  2023 och han lyckliggjorde 102 ston. Vid en första besiktning kan hingsthållaren Eeva-Liisa Penttilä berätta att 87 ston var dräktiga vid första kontrollen.</p>


<div class="factbox right minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Betäckningar Finland								</h3>
<div class="content">
<h2 class="wp-block-heading">Avelshingst – Antal (2022)</h2>
<ul class="wp-block-list">
<li>Propulsion – 102 (+101)</li>
<li>Win B. Hill – 61 (+52)</li>
<li>Maharajah – 53 (-15)</li>
<li>Don Williams – 52 (+52)</li>
<li>Calgary Games – 52 (-12)</li>
<li>Express Duo – 50 (-100)</li>
<li>Johan Palema – 45 (+45)</li>
<li>Seven and Seven – 43 (-6)</li>
<li>Jontte Boy – 40 (-18)</li>
<li>Djali Boko – 31 (-27)</li>
<li>All Laid Out – 26 (-36)</li>
<li>Zephyr Kronos – 26 (-21)</li>
<li>Friendly Bourbon – 25 (-29)</li>
<li>Readly Express – 21 (-16)</li>
</ul>
<p class="wp-block-paragraph"><strong>Fotnot:</strong> listan upptar avelshingstar som betäckte 20 ston eller fler.</p>
</p></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p class="wp-block-paragraph">Totalt har det betäcktes 1.256 ston i Finland i år och jämfört med ifjol var det en minskning med 115 ston. Propulsion stod i en klass för sig och han följdes av <strong>Win B. Hill </strong>(61), <strong>Don Williams</strong> (52) och <strong>Express Duo</strong> (50). Sistnämnde Express Duo betäckte 150 ston 2022.</p>



<p class="wp-block-paragraph">Menhammar-hingstarna <strong>Maharajah</strong>, <strong>Calgary Games</strong> och <strong>Readly Express</strong> var mest utnyttjad av de utländska beskällarna och betäckte 53, 52 respektive 21 ston. Både Maharajah och Readly Express backade med 15 respektive 16 ston, medan Calgary Games ökade med tolv ston jämfört med 2022.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Dubbla finaler bjuds det på i <strong>Gävle</strong> (första start 18.20) ikväll, där den högst doterade är finalen i Gävleborgs Montéserie. Dit har elva ryttare kvalificerat sig genom att samla poäng i 18 försök på Bollnäs, Gävle och Hagmyren under året.</p>



<p class="wp-block-paragraph">Sveriges montéchampion Jonathan Carré vann flest lopp (fyra), medan Emilia Leo plockade flest poäng efter två segrar. De båda stod i särklass i slutsammandraget. Förstapriset i loppet är 100.000 kronor, medan segrade ryttare dessutom kammar hem ett presentkort på 10.000 kronor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/03/sebastianhallemilialeo-617x347.jpg" alt="" class="wp-image-144753"/><figcaption class="wp-element-caption">Emilia Leo. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Emilia Leo rider Oskar Kylin Blom-tränade <strong>Capital Gain C.C.</strong> (e. The Bank), som debuterar under sadel, medan Carré rider Anders Hultgrens segervane sadelspecialist <strong>Country Sound</strong> (e. Quarcio du Chene). Denne ståtar med tolv sulkysegrar på 20 starter och en av dessa togs med Carré i sadeln.</p>



<p class="wp-block-paragraph">Men hästen och ryttaren att slå är Alessandro Gocciadoro-tränade <strong>Southern Mazzarati</strong> (e. Southwind Frank), som imponerade med tre segrar och ett andrapris i monté tillsammans med Sofia Adolfsson. Att Adolfsson fungerar fint på italienarens hästar i monté visades så sent som i tisdags när Sofia vann med <strong>Synergy </strong>(e. Father Patrick) i Eskilstuna.</p>



<p class="wp-block-paragraph">B-tränarna, och vissa med K-licens, gör upp i ”amatörseriens” final, där Jari Åkerfeldt var i särklass under grundserien. Jari slår ur underläge i finalen för B-tränade hästar med 50.000 kronor i förstapris, där han kör <strong>Christer </strong>(e. Classic Photo).</p>



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



<p class="has-drop-cap wp-block-paragraph">3Adrian Kolgjinis talang <strong>Countess Face</strong> (e. Muscle Hill) satt bekvämt i ledningen ut på slutrundan i Oakskvalet på Solvalla för elva dagar sedan. 800 meter från mål tvärstannade hon plötsligt och ådömdes både startförbud och kvallopp. I eftermiddag, som avslutning på Halmstads lunchtävlingar, ska stoet ut i kvalet. Countess Face var favoritspelad i det Oakskval som vanns av <strong>Knickers Sisu </strong>(e. Southwind Frank).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/countessface-617x333.jpg" alt="" class="wp-image-508585"/><figcaption class="wp-element-caption">Countess Face och Adrian Kolgjini i ledning varvet från mål i Oakskvalet på Solvalla. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Halmstad</strong> (första start 12.20) har alltså lunchtävlingar, medan <strong>Örebro</strong> (första start 18.30) är kvällens saxbana.</p>



<p class="wp-block-paragraph">Där bjuds bland annat ett tvååringslopp, där André Eklundhs debutvinnare <strong>Limoncello Boko</strong> (e. Muscle Mass) jagar andra raka segern. Hon ställs mot Mattias Djuse-tränade <strong>Melba Westwood </strong>(e. Quite Easy), vars 1.16,7a i tävlingsdebuten ”bara” räckte till fjärdeplatsen, och Åke Lindbloms debutant <strong>Artorius</strong> (e. Explosive Matter), som är lillebror till fyraårige miljonären <strong>Friend of Elves</strong> (e. Oasis Bi).</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4 <strong>Only I Exist </strong>(e. Yall Beneath Me-Get Rich Quick) har verkligen gjort skäl för sitt namn. I de fem senaste starterna har de tvååriga stoet vunnit med sammanlagt 141 längder (!) och dragit in 81.250 dollar. Ikväll har Richard Hans sto chansen att plussa på med ytterligare 55.250 dollar på sin prissumma när finalen i <a href="https://racing.ustrotting.com/goto.aspx?target=12,92241" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,92241">Maryland Sire Stakes </a>($85.000) för tvååriga ston avgörs på Rosecroft Raceway.</p>



<p class="wp-block-paragraph">Vid sina senaste fem vinster har Only I Exist bara haft en motståndare och så även ikväll. Trots att New Concept (e. Lockkeeper) har blivit akterseglad i samtliga möten mot Only I Exist har hon dragit in 43.750 dollar och det blir ytterligare 29.750 dollar – om hon nu ”bara” slutar tvåa?</p>



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



<p class="has-drop-cap wp-block-paragraph">5 <strong>Night Brodde</strong> (e. Up and Quick) är på jakt efter sin andra triumf i Graf Kalman Hunyady Gedenkrennen (€25.000) och på söndag avgörs den 124:e upplagan av storloppet på Krieau-banan i Wien. För två år sedan toppade Lugauers travare och då vann duon på 1.13,9a/2.600 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/12/nightbrodde-617x333.jpg" alt="" class="wp-image-124221"/><figcaption class="wp-element-caption">Night Brodde och Conrad Lugauer. Foto Simon Hagen/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Förstapriset uppgår till 12.500 euro och Night Brodde ställs mot tre Derbyvinnare – <strong>Days of Thunder</strong>, <strong>Diamant Venus</strong> och <strong>Heck M Eck</strong> – men också <strong>Hooper des Chasses</strong>, vilken segrade i Graf Kalman förra året.</p>



<p class="wp-block-paragraph">Conrad Lugauer har ytterligare två vinster i Graf Kalman. Han vann själv bakom <strong>Freeman T. Porter</strong> (e. Korean) 2013 och 2018 körde sonen Marc Elias <strong>Breidabliks Nubbe</strong> (e. Lindy Lane) till seger.</p>



<h2 class="wp-block-heading">Startlista:</h2>



<p class="wp-block-paragraph"><strong>Graf Kalman Hunyady Gedenkrennen</strong> (€25.000)<br>3-14 år.<br><em>2.600 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Shining Star</strong> (e. Wishing Stone) – Hubert Brandstätter</li>



<li><strong>Diamant Venus</strong> (e. Light Kronos) – Ing. Peter Sykora</li>



<li><strong>Twigs Got U.</strong> (e. Love You) – Manfred Strebel</li>



<li><strong>Lozano Boko</strong> (e. Django Riff) – Christoph Fischer</li>



<li><strong>Heck M Eck</strong> (e. Odessa Santana) – Erich Kubes</li>



<li><strong>Hooper des Chasses</strong> (e. Quaker Jet) – Michael Nimczyk</li>



<li><strong>Days of Thunder </strong>(e. S.J.’s Caviar) – Christoph Schwarz</li>



<li><strong>Night Brodde </strong>(e. Up and Quick) – Conrad Lugauer</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6 Tomas Malmqvist-tränade <strong>Lorica</strong> (e. Booster Winner) provar lyckan vid eftermiddagens tävlingar på Parisbanan <strong>Enghien</strong> (första start kl. 16.27). Efter att inlett karriären med en tredjeplats i Cabourg och en seger i Chateaubriant tävlar idag stoet i Enghiens inledningslopp Prix de la Seine-Maritime (€38.000) över 2.150 meter där segrande tvååring erhåller 17.100 euro.</p>



<p class="wp-block-paragraph">Svenskintresse finns även i Prix de Pradelles (€40.000) för fyraåriga ston genom Marie Norbergs <strong>Justess Viking</strong> (e. Ubriaco) och så startar Laurent-Claude Abrivard-tränade, svenskfödde <strong>Invader Am</strong> (e. Muscle Hill) i Prix de la Place du Canada (€46.000) i lag med Alexandre Abrivard.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 En av de sista återstående olösta fallen i den dopinghärva som FBI nystade upp för några år sedan har gått i mål. Color Flynn har erkänt sig skyldig i domstol att han distribuerade olagliga ämnen till sulkytränaren Richard Banca på uppdrag av veterinär Louis Grasso. Under ed berättade Lynn att han administrerade prestationshöjande läkemedel till hästar på Bancas uppdrag.</p>



<p class="wp-block-paragraph">Color Flynn har dömts till två års övervakad frigivning, men kommer samtidigt bli solidariskt betalningsansvarig tillsammans med Louis Grasso och Richard Banca på 16.220.794 respektive 129.975 dollar.</p>
