
<p class="has-drop-cap wp-block-paragraph">Jägersros V75-omgång denna lördag känns ojämn. Det är skiktad klass på deltagarna i flera av loppen och vi har ingen större förhoppning att utdelningen ska skjuta i höjden.</p>



<p class="wp-block-paragraph"><strong>Brother Bill </strong>(V75-3) har blandat och gett såhär långt i år, men vi vet att han brukar hitta formen framåt höstkanten. Timo Nurmos häst möter ett klart överkomligt motstånd i veckans Gulddivisionen och vi tror att han löser uppgiften trots startspår en bit ut bakom startbilsvingen.</p>



<p class="wp-block-paragraph">Vi spelar faktiskt med honom som ensamt singelstreck och kompletterar det med två tvåhästarslås.<br>Att någon annan än <strong>Mondriaan Boko</strong> och <strong>Going Cash</strong> (V75-2) ska vinna Klass II-försöket har vi svårt att tro och i Silverdivisionen är det upplagt för att antingen<strong> Larry Wood</strong> anför hela vägen eller att <strong>Kagan</strong> (V75-7) löser loppet i spurten.<br>Den sistnämnde står närmast perfekt inne, kommer till start med bevisad toppform och har alla möjligheter att avsluta sin tid i Silverdivisionen med guld!</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/08/02v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Jägersro.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-09-02_7_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-09-02_7_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-09-02_7_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Stoeliten, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Nova Mahiron</strong> är egentligen &#8221;bara&#8221; en Silverdivisionshäst, men vi tycker ändå att hon har en lämplig uppgift framför sig i detta lopp. Faktum är att hon vann i Stoeliten på Charlottenlund redan den 14 maj i en omgivning som höll ungefär samma klass som denna gör och vi var på intet vis missnöjda med den insats hon gjorde senast i Diamantstofinalen. Tvärtom så stånkade hon på bra via 1.10 sista varvet och nu när allt talar för att hon når ledningen direkt så kan hon bli svårfångad.</li>



<li><strong>Chebba Mil </strong>övertygade stort under fjolåret då hon vann såväl Drottning Silvias Pokal som Stosprintern. I år har hon inte tävlat på samma höga nivå ännu även om hon var ute i knalltuff omgivning senast i European Championship for Mares. På bristande startsnabbhet är risken stor att hon får ett tuffare lopp än vår tipsetta och då är inte uppgiften helt enkel även om hon säkert är bästa hästen i grund och botten.</li>



<li><strong>Olga Utca </strong>flög fram i spurten i Diamantstofinalen och gick ett mycket bra slutvarv även i Smålandsmästaren som trea. Hon lär hamna långt bak i fältet från spår sju, men är en stark avslutare och fältet kommer därtill bli litet med blott nio deltagare så det går att sitta dugligt till i slutkurvan.</li>



<li><strong>Nanny&#8217;s Girl</strong> satt fast med rubbet sparat senast på Lunden och är i knallform.  Hon riskerar att bli över från start, men vi vill ändå betala för henne då hon kan få en kraftsparande sargresa.</li>



<li><strong>A Perfect Face </strong>har fått snål utdelning på sin form under sommaren och det kan bli svårt att få till en ändring på den saken från spår åtta.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>4-2-7 <strong>B: </strong>1-8-3 <strong>C: </strong>9-6-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>För ovanlighetens skull i denna klass så lyser startraketerna med sin frånvaro vilket gör att vägen ligger öppen för <strong>Nova Mahiron </strong>att nå ledningen utan större strid.</p>



<h2 class="wp-block-heading">Avd 2 – Klass II, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Mondriaan Boko </strong>föll i fjolårets tävlingsdebut, men pausade därefter i nio månader och har kommit tillbaka som en helt annan häst. Chelsea Boko-sonen har radat upp fem raka segrar och övertygat stort vid flera tillfällen. Vid debuten på svensk mark så fick han överta ledningen i tidigt skede och gick undan till säker seger efter att hållit en jämn fart på tillställningen hela vägen. Då vi håller honom som knapp spetsfavorit så är han också vårt förstaval i loppet.</li>



<li><strong>Going Cash</strong> har kommit ut som en ny häst i år efter en debutsäsong med blandade resultat. Segern i Lindesberg var förvisso en smula intetsägande, men senast var han riktigt fin då han spårade hela vägen och såg ut att ha mycket sparat via 1.12,7 sista varvet. Oavsett om han tar sig förbi direkt efter får gå på utsidan om Mondriaan Boko så ser vi honom som ett hett segerbud.</li>



<li><strong>High Hope Lee</strong> har kvalat in till såväl Drottning Silvias Pokal som Stosprintern under året, men inte fått med sig några prispengar från de loppen. Därav står hon alltjämt kvar i en låg klass och hon såg fin ut som fastlåst i Derbystoet-kvalet. Med rygg på fältets två bästa hästar kan hon få ett perfekt lopp i draget.</li>



<li><strong>Dajanov</strong> var rejäl vid dödenssegern på Axevalla och testades därefter i just ett Klass II-lopp. Den dagen fick han gå i tredjespår på slutvarvet och ge sig än längre ut i slutkurvan vilket gav stumma ben, men hästen höll ändå ihop det okej som fyra. Spår åtta är ett stort hinder, men skulle han droppa ner i dugligt läge är han med långt fram.</li>



<li><strong>Discotheque</strong> har tagit lite tid på sig, men nu tycks det börja släppa ordentligt. Han sträckte på sig fint vid spetssegern näst senast och sköt till bra senast som tvåa bakom <strong>Random Tile</strong>.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-2 <strong>B: </strong>9-8-6-4-10-11-3<strong> C: </strong>12-7-5</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Mondriaan Boko </strong>öppnade bra utan att nå ledningen i första skedet senast. När han står sida vid sida med <strong>Going Cash</strong> som vi i sin tur tror kan hålla ut <strong>Ruffian</strong> så är Mondriaan Boko knapp favorit att spetsa via solfjäderseffekten.</p>



<h2 class="wp-block-heading">Avd 3 – Gulddivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Brother Bill </strong>stod för en strålande årsdebut då han flög fram och gav Hail Mary en rejäl match om segern i The Onions lopp. Därefter underpresterade han för andra året i följd i Elitloppet, ströks i Jämtlands Stora Pris två veckor senare och sprang sig helt sonika trött i ledningen på Sundbyholm på en krävande bana. Nej, Brother Bill har inte varit riktigt sig, men ska normalt sett bolla med de här konkurrenterna om han bara är i någorlunda slag och vi har väldigt svårt att se att Timo Nurmos – vars hästar går som tåget – skulle ta ner hästen till Jägersro om han inte kände sig trygg vid att det blir leverans. I ett litet fält har Brother Bill god chans att lösa loppet oavsett hur han hamnar till initialt.</li>



<li><strong>Aetos Kronos</strong> fick gå i andraspår hela vägen i Åby Stora Pris och höll farten starkt som sexa. Han är inte lika bra som han var i fornstora dagar, men det går inte heller att begära utan man får helt sonika bedöma Aetos Kronos utifrån den nivå han kan tävla på år 2023. Den räcker för att han ska kunna göra upp om segern i det här loppet om Brother Bill inte har sin bästa dag.</li>



<li><strong>Heart of Steel </strong>var mycket positiv vid spetssegern i Vaggeryd, men vi tycker att den här uppgiften är tuffare och tror inte att han kommer få sitta still framme i ledningen.</li>



<li><strong>Usain Töll </strong>fullföljde helt okej som femma från vinnarhålet i Åby Stora Pris. Spår åtta är givetvis mörker, men vi tror att han kommer skickas iväg från start likväl och att man verkligen försöker utnyttja den häftiga startsnabbhet som Googoo Gaagaa-sonen sitter inne på.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 7 <strong>B: </strong>6-1-8 <strong>C: </strong>4-5-2-3</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Heart of Steel </strong>lär bli ordentligt utmanad av <strong>Night Brodde</strong>, men vi tror även man skickar iväg <strong>Usain Töll </strong>med full fart trots spår åtta och ser hur det går att komma till.</p>



<h2 class="wp-block-heading">Avd 4 – Klass I, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Sandokan</strong> har tidigare agerat mycket osäkert och även om han långt ifrån är fläckfri i stilen nu så har han sett betydligt bättre ut i de senaste starterna. Vid Klass I-starten senast i Mantorp var han med bra från start, kunde forceras till tät efter 600 meter och kontrade till seger över spurtrakan efter att brottats med stilen i slutkurvan. Den här gången är hästen anmäld med jänkarvagn för första gången och kan det ge honom såväl mer plats som en extra skjuts så kan Sandokan bli svårfångad.</li>



<li><strong>Kaxig In </strong>mötte just Sandokan näst senast i Mantorp. Han fick gnugga på som förstahäst i tredjespår de sista 1.100 meterna den dagen, men tog verkligen striden som trea och var knappt slagen. I Derbykvalet fick han aldrig chansen och kommer till start med &#8221;extra krafter sparade&#8221; till detta lopp.</li>



<li><strong>Tearsinheaven</strong> stod för en mycket bra upphämtning efter galopp näst senast och avgjorde enkelt från andra utvändigt i efterföljande start när han fick spara speeden tills upploppets början. Den här hästen är distansgynnad och vi ser honom som ett av de hetare buden i detta lopp.</li>



<li><strong>Pingis</strong> ser vi som en grundkapabel häst, men han har haft svårt att få den där riktigt utdelningen när han startat i lite mer kvalificerade sammanhang. Den här gången körs hästen av Magnus A Djuse för första gången och utrustas därtill med jänkarvagn för blott andra tillfället (galopp föregående försök).</li>



<li><strong>Månskenstösen</strong> var strålande bra vid segrarna i raden, men gick sig väl trött i Derbystoförsöket för att vi ska ha den där riktigt sköna känslan kring henne inför detta lopp. Stoet är därtill inte startsnabb och riskerar att hamna en bit bak på innerspår.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 5-11-4 <strong>B: </strong>3-1-2-10-6-9 <strong>C: </strong>12-8-7</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Månskenstösen</strong> är direkt långsam från start och inte heller Pingis har visat prov på startsnabbhet. <strong>Breidabliks Bombay</strong> är en av de snabbare från start, men vi tror främst på <strong>Sandokan</strong> som ledare av det här loppet när halvvarvet är passerat.</p>



<h2 class="wp-block-heading">Avd 5 – Bronsdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Crown Wise As </strong>har tuffat till sig under året och regelbundet levererat i lite hårdare sällskap. Han sköt till bra efter sen lucka från vinnarhålet näst senast och gick även bra i Bronsdivisionens final senast efter att hamnat långt bak. Från innerspår bakom bilen är spetschansen mycket god och från tät blir han svårluggad.</li>



<li><strong>Demon</strong> har trampat upp i vagn och galopperat i första kurvan två starter i följd. Han fick därtill ett blytungt lopp efter felstegen senast i Vaggeryd och gick sig fullt naturligt trött. Backar vi bandet till Sundbyholmsstarten i juli så hade han varit med långt fram i Eskilstunas Fyraåringstest utan felsteg in mot upploppet och det säger en hel del om denna hästs kunnande. Den dagen tävlade han barfota runt om och så kommer fallet även bli nu.</li>



<li><strong>Rossi Garline </strong>har ingen märkvärdig resultatrad, men formen är klart bättre än vad den ger sken av. Han fick långt fram från femte utvändigt i senaste starten, men avslutade jättebra som fyra och visade att formen är helt på topp.</li>



<li><strong>Lucifer Boko</strong> har bara gjort bra insatser på sistone i denna klass och inte heller där går det anmärka på formstatusen. Wilma Karlsson har gjort ett bra arbete bakom E L Titan-sonen, men det går inte förneka att det kittlar att Björn Goop nu svingar sig upp bakom hästen för första gången.</li>



<li><strong>Boli You S.M.</strong> är svårbedömd efter att pullat friskt i ryggar näst senast, men därefter avgjort lekande lätt från dödens i efterföljande start.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-7-9 <strong>B: </strong>11-10-5-6 <strong>C: </strong>2-8-3-4-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi bedömer <strong>Crown Wise As</strong> chans att hålla ut <strong>Federer</strong> och <strong>Dynamite Sensation </strong>som mycket god.</p>



<h2 class="wp-block-heading">Avd 6 – Diamantstoet, 2.640 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Ultra Violet </strong>blir vårt tipsval i ett mycket öppet lopp. Hon har radat upp toppinsatser en längre period och känns mest distansgynnad av de mer betrodda i det här loppet, men i senaste starten blev hon mer eller mindre knockad. Att stånka på i tredjespår från varvet före mål och nå dödens ett halvvarv senast mot knalltuffa ston blev henne övermäktigt och över upploppet var det rejält stumma ben. Nu lär André Eklundh sikta in sig på ett mer avvaktande upplägg, men får hon bara duglig draghjälp så har hon alla möjligheter att sänka samtliga.</li>



<li><strong>Garden Leave </strong>besegrade Ultra Violet vid deras möte näst senast och var riktigt rejäl efter att avancerats fram till dödens varvet före mål senast. Nu är det lång distans som gäller för första gången och därtill ska vanlig vagn på vilket inte varit fallet vid segerloppen.</li>



<li><strong>Ektara</strong> sände Robert Bergh fram till dödens i kvalet till Derbystoet och vi tycker att hon höll bra som femma utan att bli hotfull om segern. Det toppstammade stoet har en småspännande uppgift framför sig här då vi kan se henne överta ledningen och därifrån höjer hon sig flera snäpp.</li>



<li><strong>Global Collection</strong> tog ner Divane Godiva från dödens på slutrundan senast och var så pass rejäl att hon måste räknas även här.</li>



<li><strong>Jannah</strong> anförde hela vägen över just denna distans i ett Diamantstoförsök på Axevalla näst senast. Hon står småtufft inne här och går upp i klass, men går ändå inte räkna bort då hon är rejäl.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>14-15-3-12 <strong>B: </strong>5-11-2-13-6<strong> C:</strong> 1-10-8-4-9-7</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Chic</strong> är spetsfavorit från springspår, men körs knappast i den positionen över lång distans. <strong>Ektara</strong> och <strong>Jannah</strong> är utmanarna.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Kagan</strong> har fyra andra- och tredjeplatser i resultatraden i just Silverdivisionen och verkligen samlat ihop till en seger. Han satt fast med sparade krafter bakom Comes With Ages så nyligen som i lördags och har tidigare hanterat täta starter på ett bra sätt. Det finns framförallt en tydlig utmanare på förhand, men med minsta klaff på bitarna här så tror vi att Kagan blir väldigt svårslagen. </li>



<li><strong>Larry Wood</strong> vann säkert från ledningen i just denna klass i Halmstad, men var inte riktigt lika vass gången efter trots en duglig, invändig resa i högt tempo. Det kan vara så enkelt att Larry Wood är allra bäst när han får löpa ut i ledningen och även om det inte är givet att han vinner starten så är i alla fall chansen relativt god att han lyckas hålla upp innerspåret.</li>



<li><strong>Donizetti</strong> var det mycket surr om senast i samma klass när det tävlades på Romme. Han sändes fram till dödens inför slutrundan och gjorde en helt okej insats, men var chanslös att utmana Don&#8217;t Say Gar. Denna gång är hästen anmäld barfota runt om vilket blir första tillfället i år och därtill är den balans på vilken han var femma i fjolårets Derbyfinal.</li>



<li><strong>Callisto</strong> avslutade vettigt efter störning senast i Vaggeryd. Hästen är beroende av ett smyglopp och skulle han lyckas få det här så plockar han många i spurten.</li>



<li><strong>Behind Bars </strong>är extremt härdad i gällande klass och tycks i princip inte kunna göra en dålig insats. Från spår tolv kan det givetvis bli för långt fram, men vi vågar inte räkna bort hästen helt.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>9-1<strong> B: </strong>11-6-12<strong> C: </strong>7-4-5-2-3-10-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> Larry Wood och <strong>A Good Ponit </strong>lägger iväg raskt, men frågan är om inte <strong>Bravo Sabotage </strong>är ännu raskare initialt om han laddas fullt ut. Lömskt och här är ingenting givet.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 2 SEPTEMBER								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,2,4,7 (8,3)<br><strong>Avd 2: </strong>1,2 (9,8)<br><strong>Avd 3: </strong>7 Brother Bill (6,1)<br><strong>Avd 4: </strong>1,2,3,4,5,6,9,10,11 (12,8)<br><strong>Avd 5: </strong>1,5,6,7,9,10,11 (2,8)<br><strong>Avd 6: </strong>3,12,14,15 (5,11)<br><strong>Avd 7: </strong>1,9 (11,6)</p>



<p class="wp-block-paragraph"><em>4.032 rader / 2.016 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
